@cadenza.io/service 2.17.32 → 2.17.34

package/dist/browser/index.mjs

@@ -249,7 +249,7 @@ var DatabaseTask = class extends DeputyTask {
 };
 
 // src/registry/ServiceRegistry.ts
-import { GraphContext as GraphContext2 } from "@cadenza.io/core";
+import { v4 as uuid3 } from "uuid";
 
 // src/utils/environment.ts
 var isNode = typeof process !== "undefined" && process.versions?.node != null;
@@ -385,16 +385,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,
@@ -456,14 +456,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,
@@ -723,6 +723,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) {
@@ -734,12 +736,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 ?? ""
@@ -756,49 +764,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 GraphContext2(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 = uuid3();
+      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
   );
@@ -1036,15 +1100,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) {
@@ -1056,13 +1120,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,
@@ -1072,7 +1136,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,
@@ -1085,16 +1149,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) ?? []
@@ -1111,7 +1178,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,
@@ -1125,7 +1192,7 @@ var ServiceRegistry = class _ServiceRegistry {
           } else {
             emit("meta.service_registry.routeable_transport_missing", {
               serviceName,
-              serviceInstanceId: uuid6,
+              serviceInstanceId: uuid8,
               requiredRole: this.getRoutingTransportRole(),
               isFrontend: this.isFrontend
             });
@@ -1184,7 +1251,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;
         }
@@ -1599,6 +1666,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)
           );
@@ -1632,6 +1702,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,
@@ -1673,6 +1758,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,
@@ -2329,7 +2429,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,
@@ -3381,9 +3481,9 @@ var ServiceRegistry = class _ServiceRegistry {
 };
 
 // src/graph/definition/SignalTransmissionTask.ts
-import { Task as Task3 } from "@cadenza.io/core";
-import { v4 as uuid3 } from "uuid";
-var SignalTransmissionTask = class extends Task3 {
+import { Task as Task2 } from "@cadenza.io/core";
+import { v4 as uuid4 } from "uuid";
+var SignalTransmissionTask = class extends Task2 {
   /**
    * Constructs a new instance of the class and initializes it with the provided parameters.
    *
@@ -3411,7 +3511,7 @@ var SignalTransmissionTask = class extends Task3 {
    */
   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 = uuid3();
+      context.__routineExecId = uuid4();
       return context;
     };
     super(
@@ -4048,6 +4148,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();
@@ -4291,8 +4420,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(
+                    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(
-                    `Transmit signal to ${fetchId}`,
+                    frontendTransmitTaskName,
                     (c, emitter) => {
                       if (c.__signalName === void 0) {
                         return;
@@ -4757,10 +4934,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);
@@ -5835,13 +6056,13 @@ var DatabaseController = class _DatabaseController {
 };
 
 // src/Cadenza.ts
-import { v4 as uuid4 } from "uuid";
+import { v4 as uuid6 } from "uuid";
 
 // src/graph/controllers/GraphSyncController.ts
 import {
-  GraphContext as GraphContext4,
   META_ACTOR_SESSION_STATE_PERSIST_INTENT as META_ACTOR_SESSION_STATE_PERSIST_INTENT2
 } from "@cadenza.io/core";
+import { v4 as uuid5 } from "uuid";
 var ACTOR_TASK_METADATA = /* @__PURE__ */ Symbol.for("@cadenza.io/core/actor-task-meta");
 function getActorTaskRuntimeMetadata(taskFunction) {
   if (typeof taskFunction !== "function") {
@@ -5975,30 +6196,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 GraphContext4({
-          ...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 = uuid5();
+      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,
@@ -7350,7 +7610,7 @@ var CadenzaService = class {
       (transport) => !!transport
     ).map((transport) => ({
       ...transport,
-      uuid: uuid4()
+      uuid: uuid6()
     }));
   }
   static createBootstrapTransport(serviceInstanceId, role, endpoint) {
@@ -7602,7 +7862,7 @@ var CadenzaService = class {
       }
       for (const responder of responders) {
         const { task, descriptor } = responder;
-        const inquiryId = uuid4();
+        const inquiryId = uuid6();
         startTimeByTask.set(task, Date.now());
         const resolverTask = this.createEphemeralMetaTask(
           `Resolve inquiry ${inquiry} for ${descriptor.localTaskName}`,
@@ -8110,7 +8370,7 @@ var CadenzaService = class {
     this.bootstrap();
     this.validateName(serviceName);
     this.validateServiceName(serviceName);
-    const serviceId = options.customServiceId ?? uuid4();
+    const serviceId = options.customServiceId ?? uuid6();
     this.serviceRegistry.serviceName = serviceName;
     this.serviceRegistry.serviceInstanceId = serviceId;
     this.setHydrationResults(options.hydration);
@@ -8247,7 +8507,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) {
@@ -8955,12 +9215,12 @@ import {
   Actor as Actor2,
   DebounceTask as DebounceTask2,
   EphemeralTask as EphemeralTask2,
-  GraphRoutine as GraphRoutine3,
-  Task as Task6
+  GraphRoutine as GraphRoutine2,
+  Task as Task5
 } from "@cadenza.io/core";
 
 // src/ssr/createSSRInquiryBridge.ts
-import { v4 as uuid5 } from "uuid";
+import { v4 as uuid7 } from "uuid";
 function ensureFetch() {
   if (typeof globalThis.fetch !== "function") {
     throw new Error("SSR inquiry bridge requires global fetch support.");
@@ -9049,7 +9309,7 @@ function createSSRInquiryBridge(options = {}) {
         __remoteRoutineName: remoteRoutineName,
         __metadata: {
           ...context.__metadata ?? {},
-          __deputyExecId: uuid5()
+          __deputyExecId: uuid7()
         }
       }),
       signal
@@ -9239,13 +9499,13 @@ export {
   DeputyTask,
   EphemeralTask2 as EphemeralTask,
   GraphMetadataController,
-  GraphRoutine3 as GraphRoutine,
+  GraphRoutine2 as GraphRoutine,
   RestController,
   ServiceRegistry,
   SignalController,
   SignalTransmissionTask,
   SocketController,
-  Task6 as Task,
+  Task5 as Task,
   createSSRInquiryBridge,
   index_default as default
 };