service-bridge 1.7.0-dev.50 → 1.7.0-dev.51

package/dist/index.js

@@ -102,12 +102,12 @@ var SB_MESSAGES = {
   [SB.WORKER_TLS_CA_REQUIRED]: "A TLS CA certificate is required when starting the worker with TLS.",
   [SB.DUPLICATE_EVENT_CONSUMER_GROUP]: "Duplicate event consumer group for this pattern; use a unique pattern per handler.",
   [SB.FROZEN_AFTER_START]: "This registration cannot be changed after start(); configure handlers and outbound declarations before start().",
-  [SB.UNDECLARED_OUTBOUND_RPC]: "Outbound RPC was not declared; call callsRpc(fn) before invoking this RPC when strict outbound declarations are enabled.",
+  [SB.UNDECLARED_OUTBOUND_RPC]: "Outbound RPC was not declared; call rpc.declare(fn) before invoking this RPC when strict outbound declarations are enabled.",
   [SB.RECONCILE_FAILED_PRECONDITION]: "Registration reconcile failed: the runtime rejected the current declaration state (FailedPrecondition).",
-  [SB.JOB_RPC_ARGS_REQUIRED]: "job(): service and function name are required for RPC jobs.",
-  [SB.JOB_VIA_MISMATCH]: "job(): via must be 'rpc' when using the (service, fn, opts) form.",
-  [SB.JOB_TARGET_FORM_REQUIRED]: "job(): use job(service, fn, opts) when via is 'rpc'.",
-  [SB.EXECUTE_WORKFLOW_ARGS_REQUIRED]: "executeWorkflow(): service name and workflow name are required.",
+  [SB.JOB_RPC_ARGS_REQUIRED]: "jobs.run(): service and function name are required for RPC jobs.",
+  [SB.JOB_VIA_MISMATCH]: "jobs.run(): via must be 'rpc' when using the (service, fn, opts) form.",
+  [SB.JOB_TARGET_FORM_REQUIRED]: "jobs.run(): use jobs.run(service, fn, opts) when via is 'rpc'.",
+  [SB.EXECUTE_WORKFLOW_ARGS_REQUIRED]: "workflows.run(): service name and workflow name are required.",
   [SB.WORKFLOW_NOT_CANCELLED]: "The workflow was not cancelled.",
   [SB.INTERNAL_INVARIANT_VIOLATION]: "Internal SDK invariant was violated.",
   [SB.HANDLER_RETURNED_FAILURE]: "The RPC handler reported a failure.",
@@ -2030,7 +2030,7 @@ function servicebridge(url, serviceKey, opts = {}) {
       return { ack: true };
     });
   }
-  async function handleRpc(call, cb) {
+  async function workerGrpcHandle(call, cb) {
     const entry = lookupFnHandler(call.request.function_name || "");
     const allowedCallers = entry?.opts.allowedCallers;
     if (!requirePeerCN(call, allowedCallers, false)) {
@@ -2365,293 +2365,406 @@ function servicebridge(url, serviceKey, opts = {}) {
       return;
     }
   }
-  const svc = {
-    async rpc(fn, payload, opts2) {
-      try {
-        await _controlReady;
-      } catch (err) {
-        throw normalizeServiceError(err, "control-plane");
-      }
-      const lookupKey = fn.trim();
-      if (!lookupKey) {
-        throw new ServiceBridgeError({
-          code: SB.RPC_FN_REQUIRED,
-          message: SB_MESSAGES[SB.RPC_FN_REQUIRED],
-          component: "sdk",
-          operation: "rpc",
-          severity: "fatal"
-        });
-      }
-      const tc = traceStorage.getStore();
-      const traceId = opts2?.traceId ?? tc?.traceId ?? crypto.randomUUID();
-      const maxRetries = normalizeNonNegativeInt(opts2?.retries ?? globalOpts.retries ?? 3, 3);
-      const baseDelay = normalizePositiveInt(opts2?.retryDelay ?? globalOpts.retryDelay ?? 300, 300);
-      const timeout = normalizePositiveInt(opts2?.timeout ?? globalOpts.timeout ?? 30000, 30000);
-      let functionKey = resolveFunctionKey(lookupKey);
-      if (!functionKey) {
-        await doLookupFunction(lookupKey);
-        functionKey = resolveFunctionKey(lookupKey);
-      }
-      if (!functionKey) {
-        throw new ServiceBridgeError({
-          code: SB.NO_RPC_ENDPOINTS,
-          message: `No endpoints available for RPC: ${lookupKey}`,
-          component: "worker",
-          operation: lookupKey,
-          severity: "fatal"
-        });
-      }
-      assertOutboundRpcDeclaredForTarget(functionKey);
-      const fmeta = functionMeta.get(functionKey);
-      if (fmeta && !containsOrAll(fmeta.allowedCallers, service)) {
-        throw new ServiceBridgeError({
-          code: SB.RPC_CALLER_NOT_ALLOWED,
-          message: `Service "${service}" is not allowed to call "${lookupKey}". Permitted callers: ${fmeta.allowedCallers.join(", ") || "(none)"}.`,
-          component: "sdk",
-          operation: "rpc",
-          severity: "fatal"
+  async function rpcInvoke(fn, payload, opts2) {
+    try {
+      await _controlReady;
+    } catch (err) {
+      throw normalizeServiceError(err, "control-plane");
+    }
+    const lookupKey = fn.trim();
+    if (!lookupKey) {
+      throw new ServiceBridgeError({
+        code: SB.RPC_FN_REQUIRED,
+        message: SB_MESSAGES[SB.RPC_FN_REQUIRED],
+        component: "sdk",
+        operation: "rpc",
+        severity: "fatal"
+      });
+    }
+    const tc = traceStorage.getStore();
+    const traceId = opts2?.traceId ?? tc?.traceId ?? crypto.randomUUID();
+    const maxRetries = normalizeNonNegativeInt(opts2?.retries ?? globalOpts.retries ?? 3, 3);
+    const baseDelay = normalizePositiveInt(opts2?.retryDelay ?? globalOpts.retryDelay ?? 300, 300);
+    const timeout = normalizePositiveInt(opts2?.timeout ?? globalOpts.timeout ?? 30000, 30000);
+    let functionKey = resolveFunctionKey(lookupKey);
+    if (!functionKey) {
+      await doLookupFunction(lookupKey);
+      functionKey = resolveFunctionKey(lookupKey);
+    }
+    if (!functionKey) {
+      throw new ServiceBridgeError({
+        code: SB.NO_RPC_ENDPOINTS,
+        message: `No endpoints available for RPC: ${lookupKey}`,
+        component: "worker",
+        operation: lookupKey,
+        severity: "fatal"
+      });
+    }
+    assertOutboundRpcDeclaredForTarget(functionKey);
+    const fmeta = functionMeta.get(functionKey);
+    if (fmeta && !containsOrAll(fmeta.allowedCallers, service)) {
+      throw new ServiceBridgeError({
+        code: SB.RPC_CALLER_NOT_ALLOWED,
+        message: `Service "${service}" is not allowed to call "${lookupKey}". Permitted callers: ${fmeta.allowedCallers.join(", ") || "(none)"}.`,
+        component: "sdk",
+        operation: "rpc",
+        severity: "fatal"
+      });
+    }
+    const inputSchema = fmeta?.inputSchema;
+    const outputSchema = fmeta?.outputSchema;
+    const inputBuf = inputSchema ? encodeWithSchema(inputSchema, payload) : toJsonBuffer(payload);
+    const telemetryInputBuf = toJsonBuffer(payload);
+    const rpcFnName = fmeta?.fnName ?? lookupKey;
+    const rpcServiceName = fmeta?.serviceName ?? "";
+    const rootSpanId = crypto.randomUUID();
+    const parentSpanId = opts2?.parentSpanId ?? tc?.spanId ?? "";
+    const rootStartedAt = Date.now();
+    const hasRetries = maxRetries > 0;
+    reportCallStartAsync(traceId, rootSpanId, parentSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, 1, "rpc", rpcServiceName);
+    return traceStorage.run({ traceId, spanId: rootSpanId }, async () => {
+      if (opts2?.mode === "proxy") {
+        return await new Promise((resolve, reject) => {
+          stub.ProxyCall({
+            function_name: rpcFnName,
+            payload: inputBuf,
+            trace_id: traceId,
+            span_id: rootSpanId,
+            timeout_ms: timeout
+          }, meta, { deadline: new Date(Date.now() + timeout) }, (err, res) => {
+            if (err) {
+              reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, false, 1, undefined, String(err), "rpc", parentSpanId, rpcServiceName);
+              return reject(normalizeServiceError(err, lookupKey, "control-plane"));
+            }
+            if (!res?.success) {
+              const errMsg = res?.error ?? "proxy call failed";
+              reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, false, 1, undefined, errMsg, "rpc", parentSpanId, rpcServiceName);
+              return reject(normalizeServiceError(new Error(errMsg), lookupKey, "worker"));
+            }
+            reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, true, 1, res.output, "", "rpc", parentSpanId, rpcServiceName);
+            try {
+              const out = res.output?.length ? outputSchema ? decodeWithSchema(outputSchema, res.output) : JSON.parse(res.output.toString()) : undefined;
+              resolve(out);
+            } catch (parseErr) {
+              reject(new Error(`Failed to parse proxy response: ${parseErr}`));
+            }
+          });
         });
       }
-      const inputSchema = fmeta?.inputSchema;
-      const outputSchema = fmeta?.outputSchema;
-      const inputBuf = inputSchema ? encodeWithSchema(inputSchema, payload) : toJsonBuffer(payload);
-      const telemetryInputBuf = toJsonBuffer(payload);
-      const rpcFnName = fmeta?.fnName ?? lookupKey;
-      const rpcServiceName = fmeta?.serviceName ?? "";
-      const rootSpanId = crypto.randomUUID();
-      const parentSpanId = opts2?.parentSpanId ?? tc?.spanId ?? "";
-      const rootStartedAt = Date.now();
-      const hasRetries = maxRetries > 0;
-      reportCallStartAsync(traceId, rootSpanId, parentSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, 1, "rpc", rpcServiceName);
-      return traceStorage.run({ traceId, spanId: rootSpanId }, async () => {
-        if (opts2?.mode === "proxy") {
-          return await new Promise((resolve, reject) => {
-            stub.ProxyCall({
-              function_name: rpcFnName,
-              payload: inputBuf,
-              trace_id: traceId,
-              span_id: rootSpanId,
-              timeout_ms: timeout
-            }, meta, { deadline: new Date(Date.now() + timeout) }, (err, res) => {
-              if (err) {
-                reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, false, 1, undefined, String(err), "rpc", parentSpanId, rpcServiceName);
-                return reject(normalizeServiceError(err, lookupKey, "control-plane"));
-              }
-              if (!res?.success) {
-                const errMsg = res?.error ?? "proxy call failed";
-                reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, false, 1, undefined, errMsg, "rpc", parentSpanId, rpcServiceName);
-                return reject(normalizeServiceError(new Error(errMsg), lookupKey, "worker"));
-              }
-              reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, true, 1, res.output, "", "rpc", parentSpanId, rpcServiceName);
-              try {
-                const out = res.output?.length ? outputSchema ? decodeWithSchema(outputSchema, res.output) : JSON.parse(res.output.toString()) : undefined;
-                resolve(out);
-              } catch (parseErr) {
-                reject(new Error(`Failed to parse proxy response: ${parseErr}`));
-              }
-            });
-          });
+      await ensureCallerTLS();
+      const channel = getOrCreateFunctionChannel(functionKey);
+      const workerClient = new WorkerHandlerService("__channel__", grpc2.credentials.createInsecure(), { channelOverride: channel });
+      let lastError;
+      for (let attempt = 1;attempt <= maxRetries + 1; attempt++) {
+        const attemptSpanId = hasRetries ? crypto.randomUUID() : rootSpanId;
+        const attemptParentId = hasRetries ? rootSpanId : parentSpanId;
+        const attemptStartedAt = hasRetries ? Date.now() : rootStartedAt;
+        if (hasRetries) {
+          reportCallStartAsync(traceId, attemptSpanId, attemptParentId, rpcFnName, attemptStartedAt, telemetryInputBuf, attempt, "rpc", rpcServiceName);
         }
-        await ensureCallerTLS();
-        const channel = getOrCreateFunctionChannel(functionKey);
-        const workerClient = new WorkerHandlerService("__channel__", grpc2.credentials.createInsecure(), { channelOverride: channel });
-        let lastError;
-        for (let attempt = 1;attempt <= maxRetries + 1; attempt++) {
-          const attemptSpanId = hasRetries ? crypto.randomUUID() : rootSpanId;
-          const attemptParentId = hasRetries ? rootSpanId : parentSpanId;
-          const attemptStartedAt = hasRetries ? Date.now() : rootStartedAt;
-          if (hasRetries) {
-            reportCallStartAsync(traceId, attemptSpanId, attemptParentId, rpcFnName, attemptStartedAt, telemetryInputBuf, attempt, "rpc", rpcServiceName);
+        try {
+          const attemptTimeoutMs = timeout;
+          const deadline = new Date(Date.now() + attemptTimeoutMs);
+          const workerFnName = fmeta?.fnName ?? lookupKey;
+          if (!workerFnName) {
+            throw new ServiceBridgeError({
+              code: SB.INTERNAL_INVARIANT_VIOLATION,
+              message: SB_MESSAGES[SB.INTERNAL_INVARIANT_VIOLATION],
+              component: "sdk",
+              operation: "rpc",
+              severity: "fatal"
+            });
           }
-          try {
-            const attemptTimeoutMs = timeout;
-            const deadline = new Date(Date.now() + attemptTimeoutMs);
-            const workerFnName = fmeta?.fnName ?? lookupKey;
-            if (!workerFnName) {
-              throw new ServiceBridgeError({
-                code: SB.INTERNAL_INVARIANT_VIOLATION,
-                message: SB_MESSAGES[SB.INTERNAL_INVARIANT_VIOLATION],
+          const res = await new Promise((resolve, reject) => {
+            let settled = false;
+            let unaryCall;
+            const timeoutTimer = setTimeout(() => {
+              if (settled)
+                return;
+              settled = true;
+              try {
+                unaryCall?.cancel?.();
+              } catch {}
+              reject(new ServiceBridgeError({
+                code: SB.NON_GRPC,
+                message: `rpc attempt timeout after ${attemptTimeoutMs}ms`,
                 component: "sdk",
                 operation: "rpc",
                 severity: "fatal"
-              });
-            }
-            const res = await new Promise((resolve, reject) => {
-              let settled = false;
-              let unaryCall;
-              const timeoutTimer = setTimeout(() => {
-                if (settled)
-                  return;
-                settled = true;
-                try {
-                  unaryCall?.cancel?.();
-                } catch {}
-                reject(new ServiceBridgeError({
-                  code: SB.NON_GRPC,
-                  message: `rpc attempt timeout after ${attemptTimeoutMs}ms`,
-                  component: "sdk",
-                  operation: "rpc",
-                  severity: "fatal"
-                }));
-              }, attemptTimeoutMs);
-              const finish = (err, response) => {
-                if (settled)
-                  return;
-                settled = true;
-                clearTimeout(timeoutTimer);
-                if (err) {
-                  reject(err);
-                  return;
-                }
-                resolve(response ?? { success: false, error: "empty response" });
-              };
-              try {
-                unaryCall = workerClient.Handle({
-                  function_name: workerFnName,
-                  payload: inputBuf,
-                  trace_id: traceId,
-                  span_id: attemptSpanId,
-                  parent_span_id: hasRetries ? rootSpanId : ""
-                }, makeWorkerMeta(), { deadline, waitForReady: true }, finish);
-              } catch (err) {
-                finish(err);
+              }));
+            }, attemptTimeoutMs);
+            const finish = (err, response) => {
+              if (settled)
+                return;
+              settled = true;
+              clearTimeout(timeoutTimer);
+              if (err) {
+                reject(err);
+                return;
               }
-            });
-            if (!res?.success) {
-              throw new ServiceBridgeError({
-                code: SB.HANDLER_RETURNED_FAILURE,
-                message: res?.error?.trim() || SB_MESSAGES[SB.HANDLER_RETURNED_FAILURE],
-                component: "worker",
-                operation: "rpc",
-                severity: "fatal"
-              });
-            }
-            const outputBuf = res.output ?? Buffer.alloc(0);
-            const result = outputSchema ? decodeWithSchema(outputSchema, outputBuf) : outputBuf?.length ? JSON.parse(outputBuf.toString()) : {};
-            const encodedOutput = outputBuf?.length ? toJsonBuffer(result) : Buffer.alloc(0);
-            if (hasRetries) {
-              reportCallAsync(traceId, attemptSpanId, rpcFnName, attemptStartedAt, telemetryInputBuf, true, attempt, encodedOutput, "", "rpc", attemptParentId, rpcServiceName);
-              reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, true, attempt, encodedOutput, "", "rpc", parentSpanId, rpcServiceName);
-            } else {
-              reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, true, attempt, encodedOutput, "", "rpc", parentSpanId, rpcServiceName);
+              resolve(response ?? { success: false, error: "empty response" });
+            };
+            try {
+              unaryCall = workerClient.Handle({
+                function_name: workerFnName,
+                payload: inputBuf,
+                trace_id: traceId,
+                span_id: attemptSpanId,
+                parent_span_id: hasRetries ? rootSpanId : ""
+              }, makeWorkerMeta(), { deadline, waitForReady: true }, finish);
+            } catch (err) {
+              finish(err);
             }
-            return result;
-          } catch (e) {
-            lastError = e;
-            const errMsg = normalizeUnknownErrorMessage(e);
-            if (hasRetries) {
-              reportCallAsync(traceId, attemptSpanId, rpcFnName, attemptStartedAt, telemetryInputBuf, false, attempt, undefined, errMsg, "rpc", attemptParentId, rpcServiceName);
-              if (attempt > maxRetries) {
-                reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, false, attempt, undefined, errMsg, "rpc", parentSpanId, rpcServiceName);
-              }
-            } else {
+          });
+          if (!res?.success) {
+            throw new ServiceBridgeError({
+              code: SB.HANDLER_RETURNED_FAILURE,
+              message: res?.error?.trim() || SB_MESSAGES[SB.HANDLER_RETURNED_FAILURE],
+              component: "worker",
+              operation: "rpc",
+              severity: "fatal"
+            });
+          }
+          const outputBuf = res.output ?? Buffer.alloc(0);
+          const result = outputSchema ? decodeWithSchema(outputSchema, outputBuf) : outputBuf?.length ? JSON.parse(outputBuf.toString()) : {};
+          const encodedOutput = outputBuf?.length ? toJsonBuffer(result) : Buffer.alloc(0);
+          if (hasRetries) {
+            reportCallAsync(traceId, attemptSpanId, rpcFnName, attemptStartedAt, telemetryInputBuf, true, attempt, encodedOutput, "", "rpc", attemptParentId, rpcServiceName);
+            reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, true, attempt, encodedOutput, "", "rpc", parentSpanId, rpcServiceName);
+          } else {
+            reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, true, attempt, encodedOutput, "", "rpc", parentSpanId, rpcServiceName);
+          }
+          return result;
+        } catch (e) {
+          lastError = e;
+          const errMsg = normalizeUnknownErrorMessage(e);
+          if (hasRetries) {
+            reportCallAsync(traceId, attemptSpanId, rpcFnName, attemptStartedAt, telemetryInputBuf, false, attempt, undefined, errMsg, "rpc", attemptParentId, rpcServiceName);
+            if (attempt > maxRetries) {
               reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, false, attempt, undefined, errMsg, "rpc", parentSpanId, rpcServiceName);
             }
-            if (attempt <= maxRetries) {
-              await new Promise((r) => setTimeout(r, baseDelay * 2 ** (attempt - 1)));
-            }
+          } else {
+            reportCallAsync(traceId, rootSpanId, rpcFnName, rootStartedAt, telemetryInputBuf, false, attempt, undefined, errMsg, "rpc", parentSpanId, rpcServiceName);
+          }
+          if (attempt <= maxRetries) {
+            await new Promise((r) => setTimeout(r, baseDelay * 2 ** (attempt - 1)));
           }
         }
-        throw normalizeServiceError(lastError, lookupKey, "worker");
-      });
-    },
-    event(topic, payload, opts2) {
-      if (!isOnline) {
-        enqueueOffline({ type: "event", topic, payload, opts: opts2 });
-        return Promise.resolve("");
       }
-      const tc = traceStorage.getStore();
-      return new Promise((resolve, reject) => {
-        stub.Publish({
+      throw normalizeServiceError(lastError, lookupKey, "worker");
+    });
+  }
+  const svc = {
+    rpc: {
+      handle(fn, handler, opts2) {
+        assertRegistrationsNotFrozen("handle-rpc");
+        fnHandlers.set(fn, { handler, opts: opts2 ?? {} });
+        return svc;
+      },
+      declare(fn) {
+        assertRegistrationsNotFrozen("calls-rpc");
+        outgoingDeps.push({
+          dep_type: "rpc",
+          target_service: "",
+          target_resource: fn
+        });
+      },
+      invoke: rpcInvoke
+    },
+    events: {
+      handle(pattern, handler, opts2) {
+        assertRegistrationsNotFrozen("handle-event");
+        const normalizedOpts = opts2 ?? {};
+        const groupName = `${defaultConsumerPrefix}.${pattern}`;
+        if (eventHandlers.has(groupName)) {
+          throw new ServiceBridgeError({
+            code: SB.DUPLICATE_EVENT_CONSUMER_GROUP,
+            message: `${SB_MESSAGES[SB.DUPLICATE_EVENT_CONSUMER_GROUP]} Group: "${groupName}".`,
+            component: "sdk",
+            operation: "handle-event",
+            severity: "fatal"
+          });
+        }
+        eventHandlers.set(groupName, {
+          groupName,
+          pattern,
+          handler,
+          opts: normalizedOpts
+        });
+        return svc;
+      },
+      declare(topic) {
+        assertRegistrationsNotFrozen("calls-event");
+        outgoingDeps.push({
+          dep_type: "event",
+          target_service: "",
+          target_resource: topic
+        });
+      },
+      publish(topic, payload, opts2) {
+        if (!isOnline) {
+          enqueueOffline({ type: "event", topic, payload, opts: opts2 });
+          return Promise.resolve("");
+        }
+        const tc = traceStorage.getStore();
+        return new Promise((resolve, reject) => {
+          stub.Publish({
+            topic,
+            payload: toJsonBuffer(payload),
+            headers: toWireStringMap(opts2?.headers),
+            trace_id: opts2?.traceId ?? tc?.traceId ?? "",
+            parent_span_id: opts2?.parentSpanId ?? tc?.spanId ?? "",
+            producer_service: defaultConsumerPrefix,
+            idempotency_key: opts2?.idempotencyKey ?? ""
+          }, meta, unaryDeadlineOptions(), (err, res) => err ? reject(normalizeServiceError(err, `publish:${topic}`)) : resolve(res?.message_id ?? ""));
+        });
+      },
+      publishWorker(topic, payload, opts2) {
+        const stream = workerSessionStream;
+        if (!stream) {
+          return Promise.reject(new Error("events.publishWorker requires an active worker session (call start() first)"));
+        }
+        const tc = traceStorage.getStore();
+        const requestId = crypto.randomUUID();
+        const msg = {
+          request_id: requestId,
           topic,
           payload: toJsonBuffer(payload),
           headers: toWireStringMap(opts2?.headers),
           trace_id: opts2?.traceId ?? tc?.traceId ?? "",
-          parent_span_id: opts2?.parentSpanId ?? tc?.spanId ?? "",
-          producer_service: defaultConsumerPrefix,
-          idempotency_key: opts2?.idempotencyKey ?? ""
-        }, meta, unaryDeadlineOptions(), (err, res) => err ? reject(normalizeServiceError(err, `publish:${topic}`)) : resolve(res?.message_id ?? ""));
-      });
-    },
-    publishEvent(topic, payload, opts2) {
-      const stream = workerSessionStream;
-      if (!stream) {
-        return Promise.reject(new Error("publishEvent requires an active worker session (call start() first)"));
+          parent_span_id: opts2?.parentSpanId ?? tc?.spanId ?? ""
+        };
+        return new Promise((resolve, reject) => {
+          const timer = setTimeout(() => {
+            pendingPublishAcks.delete(requestId);
+            reject(new Error(`publishWorker timed out after 30 s (topic="${topic}", request_id="${requestId}")`));
+          }, 30000);
+          pendingPublishAcks.set(requestId, { resolve, reject, timer });
+          try {
+            stream.write({ publish_message: msg });
+          } catch (err) {
+            pendingPublishAcks.delete(requestId);
+            clearTimeout(timer);
+            reject(normalizeServiceError(err, `publish-event:${topic}`));
+          }
+        });
       }
-      const tc = traceStorage.getStore();
-      const requestId = crypto.randomUUID();
-      const msg = {
-        request_id: requestId,
-        topic,
-        payload: toJsonBuffer(payload),
-        headers: toWireStringMap(opts2?.headers),
-        trace_id: opts2?.traceId ?? tc?.traceId ?? "",
-        parent_span_id: opts2?.parentSpanId ?? tc?.spanId ?? ""
-      };
-      return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-          pendingPublishAcks.delete(requestId);
-          reject(new Error(`publishEvent timed out after 30 s (topic="${topic}", request_id="${requestId}")`));
-        }, 30000);
-        pendingPublishAcks.set(requestId, { resolve, reject, timer });
-        try {
-          stream.write({ publish_message: msg });
-        } catch (err) {
-          pendingPublishAcks.delete(requestId);
-          clearTimeout(timer);
-          reject(normalizeServiceError(err, `publish-event:${topic}`));
-        }
-      });
     },
-    handleRpc(fn, handler, opts2) {
-      assertRegistrationsNotFrozen("handle-rpc");
-      fnHandlers.set(fn, { handler, opts: opts2 ?? {} });
-      return svc;
-    },
-    callsRpc(fn) {
-      assertRegistrationsNotFrozen("calls-rpc");
-      outgoingDeps.push({
-        dep_type: "rpc",
-        target_service: "",
-        target_resource: fn
-      });
-    },
-    callsEvent(topic) {
-      assertRegistrationsNotFrozen("calls-event");
-      outgoingDeps.push({
-        dep_type: "event",
-        target_service: "",
-        target_resource: topic
-      });
-    },
-    callsWorkflow(service2, name) {
-      assertRegistrationsNotFrozen("calls-workflow");
-      outgoingDeps.push({
-        dep_type: "workflow",
-        target_service: service2,
-        target_resource: name
-      });
+    jobs: {
+      run: async (serviceOrTarget, fnOrOpts, optsOrUndefined) => {
+        let target2;
+        let opts2;
+        if (typeof fnOrOpts === "string") {
+          const service2 = serviceOrTarget.trim();
+          const fn = fnOrOpts.trim();
+          opts2 = optsOrUndefined ?? { via: "rpc" };
+          if (!service2 || !fn) {
+            throw new ServiceBridgeError({
+              code: SB.JOB_RPC_ARGS_REQUIRED,
+              message: SB_MESSAGES[SB.JOB_RPC_ARGS_REQUIRED],
+              component: "sdk",
+              operation: "job",
+              severity: "fatal"
+            });
+          }
+          if (opts2.via !== "rpc") {
+            throw new ServiceBridgeError({
+              code: SB.JOB_VIA_MISMATCH,
+              message: SB_MESSAGES[SB.JOB_VIA_MISMATCH],
+              component: "sdk",
+              operation: "job",
+              severity: "fatal"
+            });
+          }
+          target2 = `${service2}/${fn}`;
+        } else {
+          target2 = serviceOrTarget;
+          opts2 = fnOrOpts;
+          if (opts2.via === "rpc") {
+            throw new ServiceBridgeError({
+              code: SB.JOB_TARGET_FORM_REQUIRED,
+              message: SB_MESSAGES[SB.JOB_TARGET_FORM_REQUIRED],
+              component: "sdk",
+              operation: "job",
+              severity: "fatal"
+            });
+          }
+        }
+        jobRegistrations.set(target2, { target: target2, opts: opts2 });
+        if (isOnline) {
+          await reconcileRegistrations(`job:${target2}`).catch((err) => {
+            reportSDKError(`register-job:${target2}`, err);
+          });
+        } else {
+          enqueueOffline({ type: "job", target: target2, opts: opts2 });
+        }
+        return target2;
+      }
     },
-    handleEvent(pattern, handler, opts2) {
-      assertRegistrationsNotFrozen("handle-event");
-      const normalizedOpts = opts2 ?? {};
-      const groupName = `${defaultConsumerPrefix}.${pattern}`;
-      if (eventHandlers.has(groupName)) {
-        throw new ServiceBridgeError({
-          code: SB.DUPLICATE_EVENT_CONSUMER_GROUP,
-          message: `${SB_MESSAGES[SB.DUPLICATE_EVENT_CONSUMER_GROUP]} Group: "${groupName}".`,
-          component: "sdk",
-          operation: "handle-event",
-          severity: "fatal"
+    workflows: {
+      declare(service2, name) {
+        assertRegistrationsNotFrozen("calls-workflow");
+        outgoingDeps.push({
+          dep_type: "workflow",
+          target_service: service2,
+          target_resource: name
+        });
+      },
+      run: async (nameOrService, stepsOrName, inputOrOpts, opts2) => {
+        if (Array.isArray(stepsOrName)) {
+          const name2 = nameOrService;
+          const steps = stepsOrName;
+          const wfOpts = inputOrOpts;
+          workflowRegistrations.set(name2, { name: name2, steps, opts: wfOpts });
+          if (isOnline) {
+            await reconcileRegistrations(`workflow:${name2}`).catch((err) => {
+              reportSDKError(`register-workflow:${name2}`, err);
+            });
+          } else {
+            enqueueOffline({ type: "workflow", name: name2, steps, opts: wfOpts });
+          }
+          return name2;
+        }
+        const service2 = nameOrService;
+        const name = stepsOrName;
+        await _controlReady;
+        const svcName = service2.trim();
+        const wfName = name.trim();
+        if (!svcName || !wfName) {
+          return Promise.reject(new ServiceBridgeError({
+            code: SB.EXECUTE_WORKFLOW_ARGS_REQUIRED,
+            message: SB_MESSAGES[SB.EXECUTE_WORKFLOW_ARGS_REQUIRED],
+            component: "sdk",
+            operation: "execute-workflow",
+            severity: "fatal"
+          }));
+        }
+        const payload = toJsonBuffer(inputOrOpts ?? {});
+        const execReq = {
+          workflow_name: wfName,
+          service_name: svcName,
+          input: payload
+        };
+        const tid = opts2?.traceId?.trim();
+        if (tid) {
+          execReq.trace_id = tid;
+        }
+        const gtid = opts2?.groupTraceId?.trim();
+        if (gtid) {
+          execReq.group_trace_id = gtid;
+        }
+        return new Promise((resolve, reject) => {
+          stub.ExecuteWorkflow(execReq, meta, unaryDeadlineOptions(), (err, res) => {
+            if (err) {
+              reject(normalizeServiceError(err, "execute-workflow"));
+              return;
+            }
+            resolve({
+              traceId: res?.trace_id ?? ""
+            });
+          });
         });
       }
-      eventHandlers.set(groupName, {
-        groupName,
-        pattern,
-        handler,
-        opts: normalizedOpts
-      });
-      return svc;
     },
     async start(opts2 = {}) {
       if (workerServer) {
@@ -2675,7 +2788,7 @@ function servicebridge(url, serviceKey, opts = {}) {
       try {
         workerServer = new grpc2.Server(channelOpts);
         workerServer.addService(WorkerHandlerService.service, {
-          Handle: handleRpc,
+          Handle: workerGrpcHandle,
           Deliver: handleDeliver
         });
         const host = opts2.host || "localhost";
@@ -2801,96 +2914,6 @@ function servicebridge(url, serviceKey, opts = {}) {
         }
       }, 200);
     },
-    async job(serviceOrTarget, fnOrOpts, optsOrUndefined) {
-      let target2;
-      let opts2;
-      if (typeof fnOrOpts === "string") {
-        const service2 = serviceOrTarget.trim();
-        const fn = fnOrOpts.trim();
-        opts2 = optsOrUndefined ?? { via: "rpc" };
-        if (!service2 || !fn) {
-          throw new ServiceBridgeError({
-            code: SB.JOB_RPC_ARGS_REQUIRED,
-            message: SB_MESSAGES[SB.JOB_RPC_ARGS_REQUIRED],
-            component: "sdk",
-            operation: "job",
-            severity: "fatal"
-          });
-        }
-        if (opts2.via !== "rpc") {
-          throw new ServiceBridgeError({
-            code: SB.JOB_VIA_MISMATCH,
-            message: SB_MESSAGES[SB.JOB_VIA_MISMATCH],
-            component: "sdk",
-            operation: "job",
-            severity: "fatal"
-          });
-        }
-        target2 = `${service2}/${fn}`;
-      } else {
-        target2 = serviceOrTarget;
-        opts2 = fnOrOpts;
-        if (opts2.via === "rpc") {
-          throw new ServiceBridgeError({
-            code: SB.JOB_TARGET_FORM_REQUIRED,
-            message: SB_MESSAGES[SB.JOB_TARGET_FORM_REQUIRED],
-            component: "sdk",
-            operation: "job",
-            severity: "fatal"
-          });
-        }
-      }
-      jobRegistrations.set(target2, { target: target2, opts: opts2 });
-      if (isOnline) {
-        await reconcileRegistrations(`job:${target2}`).catch((err) => {
-          reportSDKError(`register-job:${target2}`, err);
-        });
-      } else {
-        enqueueOffline({ type: "job", target: target2, opts: opts2 });
-      }
-      return target2;
-    },
-    async workflow(name, steps, opts2) {
-      workflowRegistrations.set(name, { name, steps, opts: opts2 });
-      if (isOnline) {
-        await reconcileRegistrations(`workflow:${name}`).catch((err) => {
-          reportSDKError(`register-workflow:${name}`, err);
-        });
-      } else {
-        enqueueOffline({ type: "workflow", name, steps, opts: opts2 });
-      }
-      return name;
-    },
-    async executeWorkflow(service2, name, input, opts2) {
-      await _controlReady;
-      const svc2 = service2.trim();
-      const wfName = name.trim();
-      if (!svc2 || !wfName) {
-        return Promise.reject(new ServiceBridgeError({
-          code: SB.EXECUTE_WORKFLOW_ARGS_REQUIRED,
-          message: SB_MESSAGES[SB.EXECUTE_WORKFLOW_ARGS_REQUIRED],
-          component: "sdk",
-          operation: "execute-workflow",
-          severity: "fatal"
-        }));
-      }
-      const payload = toJsonBuffer(input ?? {});
-      return new Promise((resolve, reject) => {
-        stub.ExecuteWorkflow({
-          workflow_name: wfName,
-          service_name: svc2,
-          input: payload
-        }, meta, unaryDeadlineOptions(), (err, res) => {
-          if (err) {
-            reject(normalizeServiceError(err, "execute-workflow"));
-            return;
-          }
-          resolve({
-            traceId: res?.trace_id ?? ""
-          });
-        });
-      });
-    },
     async cancelWorkflow(traceId) {
       await _controlReady;
       await new Promise((resolve, reject) => {