@cadenza.io/service 2.17.32 → 2.17.34

package/dist/browser/index.js

@@ -30,27 +30,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Actor: () => import_core7.Actor,
+  Actor: () => import_core6.Actor,
   DatabaseController: () => DatabaseController,
   DatabaseTask: () => DatabaseTask,
-  DebounceTask: () => import_core7.DebounceTask,
+  DebounceTask: () => import_core6.DebounceTask,
   DeputyTask: () => DeputyTask,
-  EphemeralTask: () => import_core7.EphemeralTask,
+  EphemeralTask: () => import_core6.EphemeralTask,
   GraphMetadataController: () => GraphMetadataController,
-  GraphRoutine: () => import_core7.GraphRoutine,
+  GraphRoutine: () => import_core6.GraphRoutine,
   RestController: () => RestController,
   ServiceRegistry: () => ServiceRegistry,
   SignalController: () => SignalController,
   SignalTransmissionTask: () => SignalTransmissionTask,
   SocketController: () => SocketController,
-  Task: () => import_core7.Task,
+  Task: () => import_core6.Task,
   createSSRInquiryBridge: () => createSSRInquiryBridge,
   default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/Cadenza.ts
-var import_core6 = __toESM(require("@cadenza.io/core"));
+var import_core5 = __toESM(require("@cadenza.io/core"));
 
 // src/graph/definition/DeputyTask.ts
 var import_uuid = require("uuid");
@@ -300,7 +300,7 @@ var DatabaseTask = class extends DeputyTask {
 };
 
 // src/registry/ServiceRegistry.ts
-var import_core2 = require("@cadenza.io/core");
+var import_uuid3 = require("uuid");
 
 // src/utils/environment.ts
 var isNode = typeof process !== "undefined" && process.versions?.node != null;
@@ -436,16 +436,16 @@ function normalizeServiceTransportConfig(value) {
 }
 function normalizeServiceTransportDescriptor(value) {
   const raw = value ?? {};
-  const uuid6 = normalizeString(raw.uuid);
+  const uuid8 = normalizeString(raw.uuid);
   const serviceInstanceId = normalizeString(
     raw.serviceInstanceId ?? raw.service_instance_id
   );
   const config = normalizeServiceTransportConfig(raw);
-  if (!uuid6 || !serviceInstanceId || !config) {
+  if (!uuid8 || !serviceInstanceId || !config) {
     return null;
   }
   return {
-    uuid: uuid6,
+    uuid: uuid8,
     serviceInstanceId,
     role: config.role,
     origin: config.origin,
@@ -507,14 +507,14 @@ function normalizeTransportArray(value, serviceInstanceId) {
 }
 function normalizeServiceInstanceDescriptor(value) {
   const raw = value ?? {};
-  const uuid6 = normalizeString2(raw.uuid);
+  const uuid8 = normalizeString2(raw.uuid);
   const serviceName = normalizeString2(raw.serviceName ?? raw.service_name);
-  if (!uuid6 || !serviceName) {
+  if (!uuid8 || !serviceName) {
     return null;
   }
-  const transports = normalizeTransportArray(raw.transports, uuid6);
+  const transports = normalizeTransportArray(raw.transports, uuid8);
   return {
-    uuid: uuid6,
+    uuid: uuid8,
     serviceName,
     numberOfRunningGraphs: Math.max(
       0,
@@ -774,6 +774,8 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
     return rawResult;
   }
   const result = { ...rawResult };
+  delete result.__resolverOriginalContext;
+  delete result.__resolverQueryData;
   const normalizedQueryData = result.queryData && typeof result.queryData === "object" ? { ...result.queryData } : { ...queryData };
   const resolvedData = result.data ?? normalizedQueryData.data ?? queryData.data ?? ctx.data ?? ctx.__registrationData;
   if (resolvedData !== void 0 && result.data === void 0) {
@@ -785,12 +787,18 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
   result.queryData = normalizedQueryData;
   if (tableName === "service") {
     const resolvedServiceName = String(
-      result.__serviceName ?? resolvedData?.name ?? resolvedData?.service_name ?? ctx.__serviceName ?? ""
+      ctx.__serviceName ?? result.__serviceName ?? resolvedData?.name ?? resolvedData?.service_name ?? ""
     ).trim();
     if (resolvedServiceName) {
       result.__serviceName = resolvedServiceName;
     }
   }
+  const resolvedLocalServiceInstanceId = String(
+    ctx.__serviceInstanceId ?? resolvedData?.uuid ?? resolvedData?.service_instance_id ?? ""
+  ).trim();
+  if (resolvedLocalServiceInstanceId) {
+    result.__serviceInstanceId = resolvedLocalServiceInstanceId;
+  }
   if (tableName === "service_instance" || tableName === "service_instance_transport") {
     const resolvedUuid = String(
       result.uuid ?? resolvedData?.uuid ?? ctx.__serviceInstanceId ?? ""
@@ -807,49 +815,105 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
     queryData,
     options
   );
-  return CadenzaService.createUniqueMetaTask(
-    `Resolve service registry insert for ${tableName}`,
-    (ctx, emit, inquire, progressCallback) => {
+  const localExecutionRequestedSignal = `meta.service_registry.insert_execution_requested:${tableName}:local`;
+  const remoteExecutionRequestedSignal = `meta.service_registry.insert_execution_requested:${tableName}:remote`;
+  const executionResolvedSignal = `meta.service_registry.insert_execution_resolved:${tableName}`;
+  const executionFailedSignal = `meta.service_registry.insert_execution_failed:${tableName}`;
+  const createPrepareExecutionTask = (signalName) => CadenzaService.createMetaTask(
+    `Prepare service registry insert execution for ${tableName} (${signalName})`,
+    (ctx) => {
       const nextQueryData = buildServiceRegistryInsertQueryData(ctx, queryData);
-      if (tableName === "service" && nextQueryData.data === void 0) {
-        CadenzaService.log(
-          "Service registry insert resolver missing service payload.",
-          {
-            ctxKeys: ctx && typeof ctx === "object" ? Object.keys(ctx).sort() : [],
-            hasData: !!ctx && typeof ctx === "object" && (Object.prototype.hasOwnProperty.call(ctx, "data") || ctx.data !== void 0),
-            hasRegistrationData: !!ctx && typeof ctx === "object" && (Object.prototype.hasOwnProperty.call(ctx, "__registrationData") || ctx.__registrationData !== void 0),
-            serviceName: ctx?.__serviceName ?? ctx?.data?.name ?? null
-          },
-          "warning"
-        );
-      }
-      const targetTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName) ?? remoteInsertTask;
       const delegationContext = ensureDelegationContextMetadata({
         ...ctx,
         queryData: nextQueryData
       });
       delegationContext.__metadata.__skipRemoteExecution = delegationContext.__metadata.__skipRemoteExecution ?? delegationContext.__skipRemoteExecution ?? false;
       delegationContext.__metadata.__blockRemoteExecution = delegationContext.__metadata.__blockRemoteExecution ?? delegationContext.__blockRemoteExecution ?? false;
-      return Promise.resolve(
-        targetTask.execute(
-          new import_core2.GraphContext(delegationContext),
-          emit,
-          inquire,
-          progressCallback,
-          {
-            nodeId: delegationContext.__previousTaskExecutionId ?? delegationContext.__metadata?.__previousTaskExecutionId ?? `service-registry-${tableName}`,
-            routineExecId: delegationContext.__routineExecId ?? delegationContext.__metadata?.__routineExecId ?? delegationContext.__metadata?.__localRoutineExecId ?? "service-registry"
-          }
-        )
-      ).then(
-        (result) => normalizeServiceRegistryInsertResult(
-          tableName,
-          ctx,
-          nextQueryData,
-          result
-        )
+      return {
+        ...delegationContext,
+        __resolverOriginalContext: {
+          ...ctx
+        },
+        __resolverQueryData: nextQueryData
+      };
+    },
+    `Prepares ${tableName} service-registry insert payloads for runner execution.`,
+    {
+      register: false,
+      isHidden: true
+    }
+  ).doOn(signalName).emitsOnFail(executionFailedSignal);
+  const prepareLocalExecutionTask = createPrepareExecutionTask(
+    localExecutionRequestedSignal
+  );
+  const prepareRemoteExecutionTask = createPrepareExecutionTask(
+    remoteExecutionRequestedSignal
+  );
+  const finalizeExecutionTask = CadenzaService.createMetaTask(
+    `Finalize service registry insert execution for ${tableName}`,
+    (ctx, emit) => {
+      if (!ctx.__resolverRequestId) {
+        return false;
+      }
+      const normalized = normalizeServiceRegistryInsertResult(
+        tableName,
+        ctx.__resolverOriginalContext ?? ctx,
+        ctx.__resolverQueryData ?? ctx.queryData ?? {},
+        ctx
       );
+      if (!normalized || typeof normalized !== "object") {
+        return normalized;
+      }
+      emit(executionResolvedSignal, normalized);
+      return normalized;
     },
+    `Normalizes ${tableName} service-registry insert results for resolver callers.`,
+    {
+      register: false,
+      isHidden: true
+    }
+  );
+  const wiredLocalTaskNames = /* @__PURE__ */ new Set();
+  const wireExecutionTarget = (targetTask, prepareTask) => {
+    targetTask.then(finalizeExecutionTask).emitsOnFail(executionFailedSignal);
+    prepareTask.then(targetTask);
+  };
+  wireExecutionTarget(remoteInsertTask, prepareRemoteExecutionTask);
+  return CadenzaService.createUniqueMetaTask(
+    `Resolve service registry insert for ${tableName}`,
+    (ctx, emit) => new Promise((resolve) => {
+      const resolverRequestId = (0, import_uuid3.v4)();
+      CadenzaService.createEphemeralMetaTask(
+        `Resolve service registry insert execution for ${tableName} (${resolverRequestId})`,
+        (resultCtx) => {
+          if (resultCtx.__resolverRequestId !== resolverRequestId) {
+            return false;
+          }
+          const normalizedResult = {
+            ...resultCtx
+          };
+          delete normalizedResult.__resolverRequestId;
+          delete normalizedResult.__resolverOriginalContext;
+          delete normalizedResult.__resolverQueryData;
+          resolve(normalizedResult);
+          return normalizedResult;
+        },
+        `Resolves signal-driven ${tableName} service-registry insert execution.`,
+        {
+          register: false
+        }
+      ).doOn(executionResolvedSignal, executionFailedSignal);
+      const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
+      const executionSignal = localInsertTask ? localExecutionRequestedSignal : remoteExecutionRequestedSignal;
+      if (localInsertTask && !wiredLocalTaskNames.has(localInsertTask.name)) {
+        wireExecutionTarget(localInsertTask, prepareLocalExecutionTask);
+        wiredLocalTaskNames.add(localInsertTask.name);
+      }
+      emit(executionSignal, {
+        ...ctx,
+        __resolverRequestId: resolverRequestId
+      });
+    }),
     `Resolves ${tableName} inserts through the local CadenzaDB task when available.`,
     options
   );
@@ -1087,15 +1151,15 @@ var ServiceRegistry = class _ServiceRegistry {
         if (!serviceInstance) {
           return false;
         }
-        const uuid6 = serviceInstance.uuid;
+        const uuid8 = serviceInstance.uuid;
         const serviceName = serviceInstance.serviceName;
         const deleted = Boolean(
           ctx.deleted ?? ctx.serviceInstance?.deleted ?? ctx.data?.deleted
         );
-        if (uuid6 === this.serviceInstanceId) return;
+        if (uuid8 === this.serviceInstanceId) return;
         if (deleted) {
-          const existingInstance = this.instances.get(serviceName)?.find((instance) => instance.uuid === uuid6);
-          const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid6) ?? -1;
+          const existingInstance = this.instances.get(serviceName)?.find((instance) => instance.uuid === uuid8);
+          const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid8) ?? -1;
           if (indexToDelete >= 0 && existingInstance) {
             this.instances.get(serviceName)?.splice(indexToDelete, 1);
             for (const transport of existingInstance.transports) {
@@ -1107,13 +1171,13 @@ var ServiceRegistry = class _ServiceRegistry {
           if (this.instances.get(serviceName)?.length === 0) {
             this.instances.delete(serviceName);
           }
-          this.unregisterDependee(uuid6, serviceName);
+          this.unregisterDependee(uuid8, serviceName);
           return;
         }
         if (!this.instances.has(serviceName))
           this.instances.set(serviceName, []);
         const instances = this.instances.get(serviceName);
-        const existing = instances.find((i) => i.uuid === uuid6);
+        const existing = instances.find((i) => i.uuid === uuid8);
         if (existing) {
           Object.assign(existing, {
             ...serviceInstance,
@@ -1123,7 +1187,7 @@ var ServiceRegistry = class _ServiceRegistry {
         } else {
           instances.push(serviceInstance);
         }
-        const trackedInstance = existing ?? instances.find((instance) => instance.uuid === uuid6);
+        const trackedInstance = existing ?? instances.find((instance) => instance.uuid === uuid8);
         if (trackedInstance) {
           const snapshot = this.resolveRuntimeStatusSnapshot(
             trackedInstance.numberOfRunningGraphs ?? 0,
@@ -1136,16 +1200,19 @@ var ServiceRegistry = class _ServiceRegistry {
           trackedInstance.reportedAt = trackedInstance.reportedAt ?? (/* @__PURE__ */ new Date()).toISOString();
         }
         if (!serviceInstance.isBootstrapPlaceholder) {
-          this.reconcileBootstrapPlaceholderInstance(serviceName, uuid6, emit);
+          this.reconcileBootstrapPlaceholderInstance(serviceName, uuid8, emit);
         }
         if (this.serviceName === serviceName) {
           return false;
         }
+        if (trackedInstance?.isFrontend) {
+          return true;
+        }
         const trackedTransport = this.getRouteableTransport(
           trackedInstance,
           this.useSocket ? "socket" : "rest"
         );
-        if (!serviceInstance.isFrontend && (this.deputies.has(serviceName) || this.remoteIntents.has(serviceName)) || this.remoteSignals.has(serviceName)) {
+        if (this.deputies.has(serviceName) || this.remoteIntents.has(serviceName) || this.remoteSignals.has(serviceName)) {
           const communicationTypes = Array.from(
             new Set(
               this.deputies.get(serviceName)?.map((d) => d.communicationType) ?? []
@@ -1162,7 +1229,7 @@ var ServiceRegistry = class _ServiceRegistry {
             if (!clientCreated) {
               emit("meta.service_registry.dependee_registered", {
                 serviceName,
-                serviceInstanceId: uuid6,
+                serviceInstanceId: uuid8,
                 serviceTransportId: trackedTransport.uuid,
                 serviceOrigin: trackedTransport.origin,
                 transportProtocols: trackedTransport.protocols,
@@ -1176,7 +1243,7 @@ var ServiceRegistry = class _ServiceRegistry {
           } else {
             emit("meta.service_registry.routeable_transport_missing", {
               serviceName,
-              serviceInstanceId: uuid6,
+              serviceInstanceId: uuid8,
               requiredRole: this.getRoutingTransportRole(),
               isFrontend: this.isFrontend
             });
@@ -1235,7 +1302,7 @@ var ServiceRegistry = class _ServiceRegistry {
         if (ownerInstance.uuid === this.serviceInstanceId) {
           return true;
         }
-        const hasRemoteInterest = (!ownerInstance.isFrontend && (this.deputies.has(ownerInstance.serviceName) || this.remoteIntents.has(ownerInstance.serviceName)) || this.remoteSignals.has(ownerInstance.serviceName)) && transport.role === this.getRoutingTransportRole();
+        const hasRemoteInterest = !ownerInstance.isFrontend && (this.deputies.has(ownerInstance.serviceName) || this.remoteIntents.has(ownerInstance.serviceName) || this.remoteSignals.has(ownerInstance.serviceName)) && transport.role === this.getRoutingTransportRole();
         if (!hasRemoteInterest) {
           return true;
         }
@@ -1650,6 +1717,9 @@ var ServiceRegistry = class _ServiceRegistry {
           if (!instance.isActive || instance.isNonResponsive || instance.isBlocked) {
             return false;
           }
+          if (instance.isFrontend) {
+            return true;
+          }
           return Boolean(
             this.selectTransportForInstance(instance, context, preferredRole)
           );
@@ -1683,6 +1753,21 @@ var ServiceRegistry = class _ServiceRegistry {
         }
         if (__broadcast || instances[0].isFrontend) {
           for (const instance of instances) {
+            if (instance.isFrontend) {
+              const fetchId = `browser:${instance.uuid}`;
+              emit(
+                `meta.service_registry.selected_instance_for_socket:${fetchId}`,
+                {
+                  ...context,
+                  __instance: instance.uuid,
+                  __transportId: void 0,
+                  __transportOrigin: void 0,
+                  __transportProtocols: ["socket"],
+                  __fetchId: fetchId
+                }
+              );
+              continue;
+            }
             const selectedTransport2 = this.selectTransportForInstance(
               instance,
               context,
@@ -1724,6 +1809,21 @@ var ServiceRegistry = class _ServiceRegistry {
         if (retries > 0) {
           selected = instancesToTry[Math.floor(Math.random() * instancesToTry.length)];
         }
+        if (selected.isFrontend) {
+          context.__instance = selected.uuid;
+          context.__transportId = void 0;
+          context.__transportOrigin = void 0;
+          context.__transportProtocols = ["socket"];
+          context.__fetchId = `browser:${selected.uuid}`;
+          context.__triedInstances = triedInstances;
+          context.__triedInstances.push(selected.uuid);
+          context.__retries = retries;
+          emit(
+            `meta.service_registry.selected_instance_for_socket:${context.__fetchId}`,
+            context
+          );
+          return context;
+        }
         const selectedTransport = this.selectTransportForInstance(
           selected,
           context,
@@ -2380,7 +2480,7 @@ var ServiceRegistry = class _ServiceRegistry {
                     )
                   );
                   for (const service of services) {
-                    const instances = this.instances.get(service).filter((i) => i.isActive);
+                    const instances = this.instances.get(service).filter((i) => i.isActive && !i.isFrontend);
                     for (const instance of instances) {
                       const transport = this.getRouteableTransport(
                         instance,
@@ -3432,9 +3532,9 @@ var ServiceRegistry = class _ServiceRegistry {
 };
 
 // src/graph/definition/SignalTransmissionTask.ts
-var import_core3 = require("@cadenza.io/core");
-var import_uuid3 = require("uuid");
-var SignalTransmissionTask = class extends import_core3.Task {
+var import_core2 = require("@cadenza.io/core");
+var import_uuid4 = require("uuid");
+var SignalTransmissionTask = class extends import_core2.Task {
   /**
    * Constructs a new instance of the class and initializes it with the provided parameters.
    *
@@ -3462,7 +3562,7 @@ var SignalTransmissionTask = class extends import_core3.Task {
    */
   constructor(name, signalName, serviceName, description = "", concurrency = 0, timeout = 0, register = true, isUnique = false, isMeta = true, isSubMeta = false, isHidden = false, getTagCallback = void 0, inputSchema = void 0, validateInputContext = false, outputSchema = void 0, validateOutputContext = false, retryCount = 0, retryDelay = 0, retryDelayMax = 0, retryDelayFactor = 1) {
     const taskFunction = (context) => {
-      context.__routineExecId = (0, import_uuid3.v4)();
+      context.__routineExecId = (0, import_uuid4.v4)();
       return context;
     };
     super(
@@ -4099,6 +4199,35 @@ var SocketController = class _SocketController {
       },
       { isMeta: true }
     );
+    CadenzaService.registry.getTaskByName.doOn("meta.socket.delegation_requested");
+    CadenzaService.registry.getRoutineByName.doOn("meta.socket.delegation_requested");
+    CadenzaService.createMetaTask(
+      "Forward socket delegations to runner",
+      (context, emit) => {
+        if (!isBrowser && !CadenzaService.serviceRegistry.isFrontend) {
+          return false;
+        }
+        if (context.task || context.routine) {
+          const routine = context.task ?? context.routine;
+          delete context.task;
+          delete context.routine;
+          context.__routineExecId = context.__metadata?.__deputyExecId ?? null;
+          context.__isDeputy = true;
+          CadenzaService.runner.run(routine, context);
+          return true;
+        }
+        const deputyExecId = context.__metadata?.__deputyExecId ?? context.__deputyExecId;
+        const remoteRoutineName = context.__remoteRoutineName ?? context.__name ?? "unknown";
+        context.errored = true;
+        context.__error = `No task or routine registered for delegation target ${remoteRoutineName}.`;
+        if (deputyExecId) {
+          emit(`meta.socket.delegation_target_not_found:${deputyExecId}`, context);
+        }
+        emit("meta.runner.failed", context);
+        return false;
+      },
+      "Forwards socket delegated lookups to the local runner in frontend runtimes."
+    ).attachSignal("meta.runner.failed").doAfter(CadenzaService.registry.getTaskByName, CadenzaService.registry.getRoutineByName);
     this.registerDiagnosticsTasks();
     this.registerSocketServerTasks();
     this.registerSocketClientTasks();
@@ -4342,8 +4471,56 @@ var SocketController = class _SocketController {
                 });
                 if (ctx.isFrontend) {
                   const fetchId = `browser:${ctx.serviceInstanceId}`;
+                  const frontendDelegateTaskName = `Delegate flow to frontend ${fetchId}`;
+                  const frontendTransmitTaskName = `Transmit signal to ${fetchId}`;
+                  CadenzaService.get(frontendDelegateTaskName)?.destroy();
+                  CadenzaService.get(frontendTransmitTaskName)?.destroy();
                   CadenzaService.createMetaTask(
-                    `Transmit signal to ${fetchId}`,
+                    frontendDelegateTaskName,
+                    async (delegateCtx, emitter) => {
+                      if (delegateCtx.__remoteRoutineName === void 0) {
+                        return;
+                      }
+                      const normalizedDelegateCtx = ensureDelegationContextMetadata(delegateCtx);
+                      delete normalizedDelegateCtx.__isSubMeta;
+                      delete normalizedDelegateCtx.__broadcast;
+                      const deputyExecId = normalizedDelegateCtx.__metadata?.__deputyExecId;
+                      const resultContext = await new Promise((resolve) => {
+                        ws.timeout(normalizedDelegateCtx.__timeout ?? 6e4).emit(
+                          "delegation",
+                          normalizedDelegateCtx,
+                          (err, response) => {
+                            if (err) {
+                              resolve({
+                                ...normalizedDelegateCtx,
+                                errored: true,
+                                __error: `Frontend delegation timed out: ${err.message ?? err}`
+                              });
+                              return;
+                            }
+                            resolve(
+                              response ?? {
+                                errored: true,
+                                __error: "Frontend delegation returned no response"
+                              }
+                            );
+                          }
+                        );
+                      });
+                      if (deputyExecId) {
+                        const metadata = resultContext.__metadata;
+                        delete resultContext.__metadata;
+                        emitter(`meta.socket_client.delegated:${deputyExecId}`, {
+                          ...resultContext,
+                          ...metadata && typeof metadata === "object" ? metadata : {}
+                        });
+                      }
+                      return resultContext;
+                    },
+                    "Delegates work to a connected frontend runtime through its active websocket."
+                  ).doOn(`meta.service_registry.selected_instance_for_socket:${fetchId}`).attachSignal("meta.socket_client.delegated");
+                  CadenzaService.createMetaTask(
+                    frontendTransmitTaskName,
                     (c, emitter) => {
                       if (c.__signalName === void 0) {
                         return;
@@ -4808,10 +4985,54 @@ var SocketController = class _SocketController {
               delegationCtx
             );
           });
-          socket.on("signal", (signalCtx) => {
+          socket.on("delegation", (delegationCtx, callback) => {
+            const normalizedDelegationCtx = ensureDelegationContextMetadata(delegationCtx);
+            const deputyExecId = normalizedDelegationCtx.__metadata.__deputyExecId;
+            const targetNotFoundSignal = `meta.socket.delegation_target_not_found:${deputyExecId}`;
+            CadenzaService.createEphemeralMetaTask(
+              `Resolve frontend socket delegation ${deputyExecId}`,
+              (completedCtx) => {
+                callback(completedCtx);
+                return completedCtx;
+              },
+              "Resolves a server-routed delegation request through the frontend runtime.",
+              {
+                register: false
+              }
+            ).doOn(`meta.node.graph_completed:${deputyExecId}`, targetNotFoundSignal);
+            if (!CadenzaService.get(normalizedDelegationCtx.__remoteRoutineName) && !CadenzaService.registry.routines.get(
+              normalizedDelegationCtx.__remoteRoutineName
+            )) {
+              CadenzaService.emit(targetNotFoundSignal, {
+                ...normalizedDelegationCtx,
+                __error: `No task or routine registered for delegation target ${normalizedDelegationCtx.__remoteRoutineName}.`,
+                errored: true
+              });
+              return;
+            }
+            CadenzaService.emit("meta.socket.delegation_requested", {
+              ...normalizedDelegationCtx,
+              __name: normalizedDelegationCtx.__remoteRoutineName
+            });
+          });
+          socket.on("signal", (signalCtx, callback) => {
             if (CadenzaService.signalBroker.listObservedSignals().includes(signalCtx.__signalName)) {
+              callback?.({
+                __status: "success",
+                __signalName: signalCtx.__signalName
+              });
               CadenzaService.emit(signalCtx.__signalName, signalCtx);
+              return;
             }
+            callback?.({
+              ...signalCtx,
+              __status: "error",
+              __error: `No such signal: ${signalCtx.__signalName}`,
+              errored: true
+            });
+          });
+          socket.on("status_check", (statusCtx, callback) => {
+            callback(CadenzaService.serviceRegistry.resolveLocalStatusCheck(statusCtx));
           });
           socket.on("status_update", (status) => {
             CadenzaService.emit("meta.socket_client.status_received", status);
@@ -5481,7 +5702,7 @@ var SignalController = class _SignalController {
 };
 
 // src/graph/controllers/registerActorSessionPersistence.ts
-var import_core4 = require("@cadenza.io/core");
+var import_core3 = require("@cadenza.io/core");
 function registerActorSessionPersistenceTasks() {
   if (CadenzaService.get("Persist actor session state")) {
     return;
@@ -5602,7 +5823,7 @@ function registerActorSessionPersistenceTasks() {
     },
     "Validates and prepares actor_session_state payload for strict write-through persistence.",
     { isSubMeta: true, concurrency: 100 }
-  ).then(insertAndValidateActorSessionStateTask).respondsTo(import_core4.META_ACTOR_SESSION_STATE_PERSIST_INTENT);
+  ).then(insertAndValidateActorSessionStateTask).respondsTo(import_core3.META_ACTOR_SESSION_STATE_PERSIST_INTENT);
 }
 
 // src/graph/controllers/GraphMetadataController.ts
@@ -5886,10 +6107,11 @@ var DatabaseController = class _DatabaseController {
 };
 
 // src/Cadenza.ts
-var import_uuid4 = require("uuid");
+var import_uuid6 = require("uuid");
 
 // src/graph/controllers/GraphSyncController.ts
-var import_core5 = require("@cadenza.io/core");
+var import_core4 = require("@cadenza.io/core");
+var import_uuid5 = require("uuid");
 var ACTOR_TASK_METADATA = /* @__PURE__ */ Symbol.for("@cadenza.io/core/actor-task-meta");
 function getActorTaskRuntimeMetadata(taskFunction) {
   if (typeof taskFunction !== "function") {
@@ -5955,7 +6177,7 @@ function resolveSyncServiceName(task) {
   return taskServiceName || registryServiceName || void 0;
 }
 function isLocalOnlySyncIntent(intentName) {
-  return intentName === import_core5.META_ACTOR_SESSION_STATE_PERSIST_INTENT;
+  return intentName === import_core4.META_ACTOR_SESSION_STATE_PERSIST_INTENT;
 }
 function buildIntentRegistryData(intent) {
   const name = String(intent?.name ?? "").trim();
@@ -6023,30 +6245,69 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
   if (!localInsertTask && !remoteInsertTask) {
     return void 0;
   }
-  return CadenzaService.createUniqueMetaTask(
-    `Resolve graph sync insert for ${tableName}`,
-    (ctx, emit, inquire, progressCallback) => {
-      const targetTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName) ?? remoteInsertTask;
-      if (!targetTask) {
+  const targetTask = localInsertTask ?? remoteInsertTask;
+  const executionRequestedSignal = `meta.sync_controller.insert_execution_requested:${tableName}`;
+  const executionResolvedSignal = `meta.sync_controller.insert_execution_resolved:${tableName}`;
+  const executionFailedSignal = `meta.sync_controller.insert_execution_failed:${tableName}`;
+  const prepareExecutionTask = CadenzaService.createMetaTask(
+    `Prepare graph sync insert execution for ${tableName}`,
+    (ctx) => ({
+      ...ctx,
+      queryData: buildSyncInsertQueryData(
+        ctx,
+        queryData
+      )
+    }),
+    `Prepares ${tableName} graph-sync insert payloads for runner execution.`,
+    {
+      register: false,
+      isHidden: true
+    }
+  ).doOn(executionRequestedSignal).emitsOnFail(executionFailedSignal);
+  const finalizeExecutionTask = CadenzaService.createMetaTask(
+    `Finalize graph sync insert execution for ${tableName}`,
+    (ctx, emit) => {
+      if (!ctx.__resolverRequestId) {
         return false;
       }
-      return targetTask.execute(
-        new import_core5.GraphContext({
-          ...ctx,
-          queryData: buildSyncInsertQueryData(
-            ctx,
-            queryData
-          )
-        }),
-        emit,
-        inquire,
-        progressCallback,
+      emit(executionResolvedSignal, ctx);
+      return ctx;
+    },
+    `Resolves signal-driven ${tableName} graph-sync insert execution.`,
+    {
+      register: false,
+      isHidden: true
+    }
+  );
+  targetTask.then(finalizeExecutionTask).emitsOnFail(executionFailedSignal);
+  prepareExecutionTask.then(targetTask);
+  return CadenzaService.createUniqueMetaTask(
+    `Resolve graph sync insert for ${tableName}`,
+    (ctx, emit) => new Promise((resolve) => {
+      const resolverRequestId = (0, import_uuid5.v4)();
+      CadenzaService.createEphemeralMetaTask(
+        `Resolve graph sync insert execution for ${tableName} (${resolverRequestId})`,
+        (resultCtx) => {
+          if (resultCtx.__resolverRequestId !== resolverRequestId) {
+            return false;
+          }
+          const normalizedResult = {
+            ...resultCtx
+          };
+          delete normalizedResult.__resolverRequestId;
+          resolve(normalizedResult);
+          return normalizedResult;
+        },
+        `Waits for signal-driven ${tableName} graph-sync insert execution.`,
         {
-          nodeId: ctx.__previousTaskExecutionId ?? ctx.__metadata?.__previousTaskExecutionId ?? `graph-sync-${tableName}`,
-          routineExecId: ctx.__routineExecId ?? ctx.__metadata?.__routineExecId ?? ctx.__metadata?.__localRoutineExecId ?? "graph-sync"
+          register: false
         }
-      );
-    },
+      ).doOn(executionResolvedSignal, executionFailedSignal);
+      emit(executionRequestedSignal, {
+        ...ctx,
+        __resolverRequestId: resolverRequestId
+      });
+    }),
     `Routes graph sync inserts for ${tableName} through the local authority task when available.`,
     {
       ...options,
@@ -7351,12 +7612,12 @@ var CadenzaService = class {
   static bootstrap() {
     if (this.isBootstrapped) return;
     this.isBootstrapped = true;
-    import_core6.default.bootstrap();
-    this.signalBroker = import_core6.default.signalBroker;
-    this.inquiryBroker = import_core6.default.inquiryBroker;
-    this.runner = import_core6.default.runner;
-    this.metaRunner = import_core6.default.metaRunner;
-    this.registry = import_core6.default.registry;
+    import_core5.default.bootstrap();
+    this.signalBroker = import_core5.default.signalBroker;
+    this.inquiryBroker = import_core5.default.inquiryBroker;
+    this.runner = import_core5.default.runner;
+    this.metaRunner = import_core5.default.metaRunner;
+    this.registry = import_core5.default.registry;
     this.serviceRegistry = ServiceRegistry.instance;
     RestController.instance;
     SocketController.instance;
@@ -7390,15 +7651,15 @@ var CadenzaService = class {
       return;
     }
     this.frontendSyncScheduled = true;
-    import_core6.default.interval("meta.sync_requested", { __syncing: false }, 18e4);
-    import_core6.default.schedule("meta.sync_requested", { __syncing: false }, 250);
+    import_core5.default.interval("meta.sync_requested", { __syncing: false }, 18e4);
+    import_core5.default.schedule("meta.sync_requested", { __syncing: false }, 250);
   }
   static normalizeDeclaredTransports(transports, serviceId) {
     return (transports ?? []).map((transport) => normalizeServiceTransportConfig(transport)).filter(
       (transport) => !!transport
     ).map((transport) => ({
       ...transport,
-      uuid: (0, import_uuid4.v4)()
+      uuid: (0, import_uuid6.v4)()
     }));
   }
   static createBootstrapTransport(serviceInstanceId, role, endpoint) {
@@ -7448,7 +7709,7 @@ var CadenzaService = class {
    * @return {void} Does not return any value.
    */
   static validateName(name) {
-    import_core6.default.validateName(name);
+    import_core5.default.validateName(name);
   }
   /**
    * Gets the current run strategy from the Cadenza configuration.
@@ -7456,7 +7717,7 @@ var CadenzaService = class {
    * @return {Function} The run strategy function defined in the Cadenza configuration.
    */
   static get runStrategy() {
-    return import_core6.default.runStrategy;
+    return import_core5.default.runStrategy;
   }
   /**
    * Sets the mode for the Cadenza application.
@@ -7465,7 +7726,7 @@ var CadenzaService = class {
    * @return {void} This method does not return a value.
    */
   static setMode(mode) {
-    import_core6.default.setMode(mode);
+    import_core5.default.setMode(mode);
   }
   /**
    * Emits a signal with the specified data using the associated broker.
@@ -7483,16 +7744,16 @@ var CadenzaService = class {
    * ```
    */
   static emit(signal, data = {}, options = {}) {
-    import_core6.default.emit(signal, data, options);
+    import_core5.default.emit(signal, data, options);
   }
   static debounce(signal, context = {}, delayMs = 500) {
-    import_core6.default.debounce(signal, context, delayMs);
+    import_core5.default.debounce(signal, context, delayMs);
   }
   static schedule(signal, context, timeoutMs, exactDateTime) {
-    import_core6.default.schedule(signal, context, timeoutMs, exactDateTime);
+    import_core5.default.schedule(signal, context, timeoutMs, exactDateTime);
   }
   static interval(signal, context, intervalMs, leading = false, startDateTime) {
-    import_core6.default.interval(signal, context, intervalMs, leading, startDateTime);
+    import_core5.default.interval(signal, context, intervalMs, leading, startDateTime);
   }
   static defineIntent(intent) {
     this.inquiryBroker?.addIntent(intent);
@@ -7650,7 +7911,7 @@ var CadenzaService = class {
       }
       for (const responder of responders) {
         const { task, descriptor } = responder;
-        const inquiryId = (0, import_uuid4.v4)();
+        const inquiryId = (0, import_uuid6.v4)();
         startTimeByTask.set(task, Date.now());
         const resolverTask = this.createEphemeralMetaTask(
           `Resolve inquiry ${inquiry} for ${descriptor.localTaskName}`,
@@ -7754,7 +8015,7 @@ var CadenzaService = class {
     });
   }
   static get(taskName) {
-    return import_core6.default.get(taskName);
+    return import_core5.default.get(taskName);
   }
   static getLocalCadenzaDBTask(tableName, operation) {
     const generatedTaskName = this.buildGeneratedLocalCadenzaDBTaskName(
@@ -7765,7 +8026,7 @@ var CadenzaService = class {
       tableName,
       operation
     );
-    return import_core6.default.get(generatedTaskName) ?? import_core6.default.get(legacyTaskName);
+    return import_core5.default.get(generatedTaskName) ?? import_core5.default.get(legacyTaskName);
   }
   static getLocalCadenzaDBInsertTask(tableName) {
     return this.getLocalCadenzaDBTask(tableName, "insert");
@@ -7774,15 +8035,15 @@ var CadenzaService = class {
     return this.getLocalCadenzaDBTask(tableName, "query");
   }
   static getActor(actorName) {
-    const cadenzaWithActors = import_core6.default;
+    const cadenzaWithActors = import_core5.default;
     return cadenzaWithActors.getActor?.(actorName);
   }
   static getAllActors() {
-    const cadenzaWithActors = import_core6.default;
+    const cadenzaWithActors = import_core5.default;
     return cadenzaWithActors.getAllActors?.() ?? [];
   }
   static getRoutine(routineName) {
-    return import_core6.default.getRoutine(routineName);
+    return import_core5.default.getRoutine(routineName);
   }
   /**
    * Creates a new DeputyTask instance based on the provided routine name, service name, and options.
@@ -8158,7 +8419,7 @@ var CadenzaService = class {
     this.bootstrap();
     this.validateName(serviceName);
     this.validateServiceName(serviceName);
-    const serviceId = options.customServiceId ?? (0, import_uuid4.v4)();
+    const serviceId = options.customServiceId ?? (0, import_uuid6.v4)();
     this.serviceRegistry.serviceName = serviceName;
     this.serviceRegistry.serviceInstanceId = serviceId;
     this.setHydrationResults(options.hydration);
@@ -8295,7 +8556,7 @@ var CadenzaService = class {
           "global.meta.cadenza_db.gathered_sync_data",
           ctx.serviceName
         );
-      }).doOn("meta.rest.handshake");
+      }).doOn("meta.rest.handshake", "meta.socket.handshake");
     }
     this.createMetaTask("Handle service setup completion", () => {
       if (isFrontend) {
@@ -8310,7 +8571,7 @@ var CadenzaService = class {
       return true;
     }).doOn("meta.service_registry.instance_inserted");
     if (!options.cadenzaDB?.connect && isFrontend) {
-      import_core6.default.schedule(
+      import_core5.default.schedule(
         "meta.service_registry.instance_registration_requested",
         {
           data: {
@@ -8571,11 +8832,11 @@ var CadenzaService = class {
   }
   static createActor(spec, options = {}) {
     this.bootstrap();
-    return import_core6.default.createActor(spec, options);
+    return import_core5.default.createActor(spec, options);
   }
   static createActorFromDefinition(definition, options = {}) {
     this.bootstrap();
-    return import_core6.default.createActorFromDefinition(definition, options);
+    return import_core5.default.createActorFromDefinition(definition, options);
   }
   /**
    * Creates and registers a new task with the provided name, function, and optional details.
@@ -8649,7 +8910,7 @@ var CadenzaService = class {
    */
   static createTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core6.default.createTask(name, func, description, options);
+    return import_core5.default.createTask(name, func, description, options);
   }
   /**
    * Creates a meta task with the specified name, functionality, description, and options.
@@ -8665,7 +8926,7 @@ var CadenzaService = class {
    */
   static createMetaTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core6.default.createMetaTask(name, func, description, options);
+    return import_core5.default.createMetaTask(name, func, description, options);
   }
   /**
    * Creates a unique task by wrapping the provided task function with a uniqueness constraint.
@@ -8715,7 +8976,7 @@ var CadenzaService = class {
    */
   static createUniqueTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core6.default.createUniqueTask(name, func, description, options);
+    return import_core5.default.createUniqueTask(name, func, description, options);
   }
   /**
    * Creates a unique meta task with the specified name, function, description, and options.
@@ -8729,7 +8990,7 @@ var CadenzaService = class {
    */
   static createUniqueMetaTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core6.default.createUniqueMetaTask(name, func, description, options);
+    return import_core5.default.createUniqueMetaTask(name, func, description, options);
   }
   /**
    * Creates a throttled task with a concurrency limit of 1, ensuring that only one instance of the task can run at a time for a specific throttle tag.
@@ -8762,7 +9023,7 @@ var CadenzaService = class {
    */
   static createThrottledTask(name, func, throttledIdGetter = () => "default", description, options = {}) {
     this.bootstrap();
-    return import_core6.default.createThrottledTask(
+    return import_core5.default.createThrottledTask(
       name,
       func,
       throttledIdGetter,
@@ -8783,7 +9044,7 @@ var CadenzaService = class {
    */
   static createThrottledMetaTask(name, func, throttledIdGetter = () => "default", description, options = {}) {
     this.bootstrap();
-    return import_core6.default.createThrottledMetaTask(
+    return import_core5.default.createThrottledMetaTask(
       name,
       func,
       throttledIdGetter,
@@ -8826,7 +9087,7 @@ var CadenzaService = class {
    */
   static createDebounceTask(name, func, description, debounceTime = 1e3, options = {}) {
     this.bootstrap();
-    return import_core6.default.createDebounceTask(
+    return import_core5.default.createDebounceTask(
       name,
       func,
       description,
@@ -8847,7 +9108,7 @@ var CadenzaService = class {
    */
   static createDebounceMetaTask(name, func, description, debounceTime = 1e3, options = {}) {
     this.bootstrap();
-    return import_core6.default.createDebounceMetaTask(
+    return import_core5.default.createDebounceMetaTask(
       name,
       func,
       description,
@@ -8917,7 +9178,7 @@ var CadenzaService = class {
    */
   static createEphemeralTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core6.default.createEphemeralTask(name, func, description, options);
+    return import_core5.default.createEphemeralTask(name, func, description, options);
   }
   /**
    * Creates an ephemeral meta-task with the specified name, function, description, and options.
@@ -8931,7 +9192,7 @@ var CadenzaService = class {
    */
   static createEphemeralMetaTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core6.default.createEphemeralMetaTask(name, func, description, options);
+    return import_core5.default.createEphemeralMetaTask(name, func, description, options);
   }
   /**
    * Creates a new routine with the specified name, tasks, and an optional description.
@@ -8963,7 +9224,7 @@ var CadenzaService = class {
    */
   static createRoutine(name, tasks, description = "") {
     this.bootstrap();
-    return import_core6.default.createRoutine(name, tasks, description);
+    return import_core5.default.createRoutine(name, tasks, description);
   }
   /**
    * Creates a meta routine with a given name, tasks, and optional description.
@@ -8978,10 +9239,10 @@ var CadenzaService = class {
    */
   static createMetaRoutine(name, tasks, description = "") {
     this.bootstrap();
-    return import_core6.default.createMetaRoutine(name, tasks, description);
+    return import_core5.default.createMetaRoutine(name, tasks, description);
   }
   static reset() {
-    import_core6.default.reset();
+    import_core5.default.reset();
     this.serviceRegistry?.reset();
     this.isBootstrapped = false;
     this.serviceCreated = false;
@@ -8999,10 +9260,10 @@ CadenzaService.hydratedInquiryResults = /* @__PURE__ */ new Map();
 CadenzaService.frontendSyncScheduled = false;
 
 // src/index.ts
-var import_core7 = require("@cadenza.io/core");
+var import_core6 = require("@cadenza.io/core");
 
 // src/ssr/createSSRInquiryBridge.ts
-var import_uuid5 = require("uuid");
+var import_uuid7 = require("uuid");
 function ensureFetch() {
   if (typeof globalThis.fetch !== "function") {
     throw new Error("SSR inquiry bridge requires global fetch support.");
@@ -9091,7 +9352,7 @@ function createSSRInquiryBridge(options = {}) {
         __remoteRoutineName: remoteRoutineName,
         __metadata: {
           ...context.__metadata ?? {},
-          __deputyExecId: (0, import_uuid5.v4)()
+          __deputyExecId: (0, import_uuid7.v4)()
         }
       }),
       signal