@cadenza.io/service 2.12.0 → 2.16.0

package/dist/index.mjs

@@ -38,7 +38,7 @@ var DeputyTask = class extends Task {
           return;
         }
         if (context.__metadata.__skipRemoteExecution) {
-          resolve(true);
+          resolve(context);
           return;
         }
         const processId = uuid();
@@ -141,6 +141,8 @@ var DeputyTask = class extends Task {
       __executionTraceId: metadata.__executionTraceId ?? null,
       __metadata: {
         ...metadata,
+        __skipRemoteExecution: metadata.__skipRemoteExecution ?? ctx.__skipRemoteExecution ?? false,
+        __blockRemoteExecution: metadata.__blockRemoteExecution ?? ctx.__blockRemoteExecution ?? false,
         __deputyTaskName: this.name
       },
       ...ctx
@@ -219,6 +221,7 @@ var DatabaseTask = class extends DeputyTask {
     const dynamicQueryData = ctx.queryData ?? {};
     delete ctx.queryData;
     const deputyContext = {
+      ...ctx,
       __localTaskName: this.name,
       __localTaskVersion: this.version,
       __localServiceName: CadenzaService.serviceRegistry.serviceName,
@@ -229,6 +232,8 @@ var DatabaseTask = class extends DeputyTask {
       __localRoutineExecId: metadata.__routineExecId ?? metadata.__metadata?.__routineExecId,
       __metadata: {
         ...metadata,
+        __skipRemoteExecution: metadata.__skipRemoteExecution ?? ctx.__skipRemoteExecution ?? false,
+        __blockRemoteExecution: metadata.__blockRemoteExecution ?? ctx.__blockRemoteExecution ?? false,
         __deputyTaskName: this.name
       },
       queryData: {
@@ -315,6 +320,167 @@ function summarizeResponderStatuses(statuses) {
   return { responded, failed, timedOut, pending };
 }
 
+// src/utils/transport.ts
+var DEFAULT_PROTOCOLS = ["rest", "socket"];
+function normalizeString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function normalizeTransportProtocols(value) {
+  const rawValues = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+  const normalized = rawValues.map((entry) => normalizeString(entry)).filter(
+    (entry) => entry === "rest" || entry === "socket"
+  );
+  return Array.from(new Set(normalized));
+}
+function normalizeTransportOrigin(origin) {
+  const raw = normalizeString(origin);
+  if (!raw) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return null;
+  }
+  if (parsed.pathname && parsed.pathname !== "/") {
+    return null;
+  }
+  if (parsed.search || parsed.hash) {
+    return null;
+  }
+  return parsed.origin;
+}
+function normalizeSecurityProfile(value) {
+  const normalized = normalizeString(value);
+  if (normalized === "low" || normalized === "medium" || normalized === "high") {
+    return normalized;
+  }
+  return null;
+}
+function normalizeServiceTransportConfig(value) {
+  const raw = value ?? {};
+  const role = normalizeString(raw.role);
+  const origin = normalizeTransportOrigin(raw.origin);
+  const protocols = normalizeTransportProtocols(raw.protocols);
+  if (!origin) {
+    return null;
+  }
+  if (role !== "internal" && role !== "public") {
+    return null;
+  }
+  return {
+    role,
+    origin,
+    protocols: protocols.length > 0 ? protocols : [...DEFAULT_PROTOCOLS],
+    securityProfile: normalizeSecurityProfile(raw.securityProfile),
+    authStrategy: normalizeString(raw.authStrategy) || null
+  };
+}
+function normalizeServiceTransportDescriptor(value) {
+  const raw = value ?? {};
+  const uuid5 = normalizeString(raw.uuid);
+  const serviceInstanceId = normalizeString(
+    raw.serviceInstanceId ?? raw.service_instance_id
+  );
+  const config = normalizeServiceTransportConfig(raw);
+  if (!uuid5 || !serviceInstanceId || !config) {
+    return null;
+  }
+  return {
+    uuid: uuid5,
+    serviceInstanceId,
+    role: config.role,
+    origin: config.origin,
+    protocols: config.protocols ?? [...DEFAULT_PROTOCOLS],
+    securityProfile: config.securityProfile ?? null,
+    authStrategy: config.authStrategy ?? null,
+    deleted: Boolean(raw.deleted),
+    clientCreated: Boolean(raw.clientCreated ?? raw.client_created ?? false)
+  };
+}
+function transportSupportsProtocol(transport, protocol) {
+  return !!transport && transport.protocols.includes(protocol);
+}
+function selectTransportForRole(transports, role, protocol) {
+  const filtered = transports.filter(
+    (transport) => !transport.deleted && transport.role === role && (!protocol || transportSupportsProtocol(transport, protocol))
+  );
+  return filtered[0];
+}
+function buildTransportClientKey(transport) {
+  return transport.uuid;
+}
+function parseTransportOrigin(origin) {
+  const normalized = normalizeTransportOrigin(origin);
+  if (!normalized) {
+    return null;
+  }
+  const parsed = new URL(normalized);
+  const protocol = parsed.protocol === "https:" ? "https" : "http";
+  const port = parsed.port ? Number(parsed.port) : protocol === "https" ? 443 : 80;
+  return {
+    protocol,
+    hostname: parsed.hostname,
+    port
+  };
+}
+
+// src/utils/serviceInstance.ts
+function normalizeString2(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function normalizeTransportArray(value, serviceInstanceId) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map(
+    (entry) => normalizeServiceTransportDescriptor({
+      ...entry ?? {},
+      service_instance_id: entry?.service_instance_id ?? entry?.serviceInstanceId ?? serviceInstanceId
+    })
+  ).filter((transport) => !!transport).sort((left, right) => left.origin.localeCompare(right.origin));
+}
+function normalizeServiceInstanceDescriptor(value) {
+  const raw = value ?? {};
+  const uuid5 = normalizeString2(raw.uuid);
+  const serviceName = normalizeString2(raw.serviceName ?? raw.service_name);
+  if (!uuid5 || !serviceName) {
+    return null;
+  }
+  const transports = normalizeTransportArray(raw.transports, uuid5);
+  return {
+    uuid: uuid5,
+    serviceName,
+    numberOfRunningGraphs: Math.max(
+      0,
+      Math.trunc(
+        Number(raw.numberOfRunningGraphs ?? raw.number_of_running_graphs ?? 0) || 0
+      )
+    ),
+    isPrimary: Boolean(raw.isPrimary ?? raw.is_primary ?? false),
+    isActive: Boolean(raw.isActive ?? raw.is_active ?? true),
+    isNonResponsive: Boolean(
+      raw.isNonResponsive ?? raw.is_non_responsive ?? false
+    ),
+    isBlocked: Boolean(raw.isBlocked ?? raw.is_blocked ?? false),
+    runtimeState: raw.runtimeState === "healthy" || raw.runtimeState === "degraded" || raw.runtimeState === "overloaded" || raw.runtimeState === "unavailable" ? raw.runtimeState : void 0,
+    acceptingWork: typeof raw.acceptingWork === "boolean" ? raw.acceptingWork : void 0,
+    reportedAt: typeof raw.reportedAt === "string" ? raw.reportedAt : typeof raw.reported_at === "string" ? raw.reported_at : void 0,
+    health: raw.health ?? {},
+    isFrontend: Boolean(raw.isFrontend ?? raw.is_frontend ?? false),
+    isDatabase: Boolean(raw.isDatabase ?? raw.is_database ?? false),
+    transports,
+    clientCreatedTransportIds: Array.isArray(raw.clientCreatedTransportIds) ? raw.clientCreatedTransportIds.map((entry) => normalizeString2(entry)).filter((entry) => entry.length > 0) : void 0
+  };
+}
+function getRouteableTransport(instance, role, protocol) {
+  return selectTransportForRole(instance.transports ?? [], role, protocol);
+}
+
 // src/utils/readiness.ts
 function evaluateDependencyReadiness(input) {
   const missedHeartbeats = Math.max(
@@ -561,6 +727,7 @@ var ServiceRegistry = class _ServiceRegistry {
     this.numberOfRunningGraphs = 0;
     this.useSocket = false;
     this.retryCount = 3;
+    this.isFrontend = false;
     CadenzaService.defineIntent({
       name: META_RUNTIME_TRANSPORT_DIAGNOSTICS_INTENT,
       description: "Gather transport diagnostics across all services and communication clients.",
@@ -708,57 +875,60 @@ var ServiceRegistry = class _ServiceRegistry {
     this.handleInstanceUpdateTask = CadenzaService.createMetaTask(
       "Handle Instance Update",
       (ctx, emit) => {
-        const serviceInstance = ctx.serviceInstance ?? (ctx.__serviceInstanceId || ctx.serviceInstanceId ? {
-          uuid: ctx.__serviceInstanceId ?? ctx.serviceInstanceId,
-          serviceName: ctx.__serviceName ?? ctx.serviceName,
-          address: ctx.serviceAddress ?? "",
-          port: ctx.servicePort ?? 0,
-          exposed: !!ctx.exposed,
-          isFrontend: !!ctx.isFrontend,
-          isActive: typeof ctx.isActive === "boolean" ? ctx.isActive : typeof ctx.__active === "boolean" ? ctx.__active : true,
-          isNonResponsive: !!ctx.isNonResponsive,
-          isBlocked: !!ctx.isBlocked,
-          health: ctx.health ?? ctx.__health ?? {},
-          numberOfRunningGraphs: ctx.numberOfRunningGraphs ?? ctx.__numberOfRunningGraphs ?? 0,
-          isPrimary: false
-        } : void 0);
-        if (!serviceInstance?.uuid || !serviceInstance?.serviceName) {
+        const serviceInstance = normalizeServiceInstanceDescriptor(
+          ctx.serviceInstance ?? ctx.data ?? ctx.queryData?.data ?? (ctx.__serviceInstanceId || ctx.serviceInstanceId ? {
+            uuid: ctx.__serviceInstanceId ?? ctx.serviceInstanceId,
+            serviceName: ctx.__serviceName ?? ctx.serviceName,
+            isFrontend: !!ctx.isFrontend,
+            isActive: typeof ctx.isActive === "boolean" ? ctx.isActive : typeof ctx.__active === "boolean" ? ctx.__active : true,
+            isNonResponsive: !!ctx.isNonResponsive,
+            isBlocked: !!ctx.isBlocked,
+            health: ctx.health ?? ctx.__health ?? {},
+            numberOfRunningGraphs: ctx.numberOfRunningGraphs ?? ctx.__numberOfRunningGraphs ?? 0,
+            isPrimary: false,
+            transports: ctx.transports ?? []
+          } : void 0)
+        );
+        if (!serviceInstance) {
           return false;
         }
-        const {
-          uuid: uuid4,
-          serviceName,
-          address,
-          port,
-          exposed,
-          isFrontend,
-          deleted
-        } = serviceInstance;
-        if (uuid4 === this.serviceInstanceId) return;
+        const uuid5 = serviceInstance.uuid;
+        const serviceName = serviceInstance.serviceName;
+        const deleted = Boolean(
+          ctx.deleted ?? ctx.serviceInstance?.deleted ?? ctx.data?.deleted
+        );
+        if (uuid5 === this.serviceInstanceId) return;
         if (deleted) {
-          const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid4) ?? -1;
-          if (indexToDelete >= 0) {
+          const existingInstance = this.instances.get(serviceName)?.find((instance) => instance.uuid === uuid5);
+          const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid5) ?? -1;
+          if (indexToDelete >= 0 && existingInstance) {
             this.instances.get(serviceName)?.splice(indexToDelete, 1);
+            for (const transport of existingInstance.transports) {
+              const transportKey = buildTransportClientKey(transport);
+              emit(`meta.socket_shutdown_requested:${transportKey}`, {});
+              emit(`meta.fetch.destroy_requested:${transportKey}`, {});
+            }
           }
           if (this.instances.get(serviceName)?.length === 0) {
             this.instances.delete(serviceName);
-          } else if (this.instances.get(serviceName)?.filter((i) => i.address === address && i.port === port).length === 0) {
-            emit(`meta.socket_shutdown_requested:${address}_${port}`, {});
-            emit(`meta.fetch.destroy_requested:${address}_${port}`, {});
           }
-          this.unregisterDependee(uuid4, serviceName);
+          this.unregisterDependee(uuid5, serviceName);
           return;
         }
         if (!this.instances.has(serviceName))
           this.instances.set(serviceName, []);
         const instances = this.instances.get(serviceName);
-        const existing = instances.find((i) => i.uuid === uuid4);
+        const existing = instances.find((i) => i.uuid === uuid5);
         if (existing) {
-          Object.assign(existing, serviceInstance);
+          Object.assign(existing, {
+            ...serviceInstance,
+            transports: serviceInstance.transports.length > 0 ? serviceInstance.transports : existing.transports,
+            clientCreatedTransportIds: existing.clientCreatedTransportIds ?? []
+          });
         } else {
           instances.push(serviceInstance);
         }
-        const trackedInstance = existing ?? instances.find((instance) => instance.uuid === uuid4);
+        const trackedInstance = existing ?? instances.find((instance) => instance.uuid === uuid5);
         if (trackedInstance) {
           const snapshot = this.resolveRuntimeStatusSnapshot(
             trackedInstance.numberOfRunningGraphs ?? 0,
@@ -773,31 +943,44 @@ var ServiceRegistry = class _ServiceRegistry {
         if (this.serviceName === serviceName) {
           return false;
         }
-        if (!isFrontend && (this.deputies.has(serviceName) || this.remoteIntents.has(serviceName)) || this.remoteSignals.has(serviceName)) {
-          const clientCreated = instances?.some(
-            (i) => i.address === address && i.port === port && i.clientCreated && i.isActive
+        const trackedTransport = this.getRouteableTransport(
+          trackedInstance,
+          this.useSocket ? "socket" : "rest"
+        );
+        if (!serviceInstance.isFrontend && (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) ?? []
+            )
           );
-          if (!clientCreated) {
-            const communicationTypes = Array.from(
-              new Set(
-                this.deputies.get(serviceName)?.map((d) => d.communicationType) ?? []
-              )
+          if (!communicationTypes.includes("signal") && this.remoteSignals.has(serviceName)) {
+            communicationTypes.push("signal");
+          }
+          if (trackedTransport) {
+            const clientCreated = this.hasTransportClientCreated(
+              trackedInstance,
+              trackedTransport.uuid
             );
-            if (!communicationTypes.includes("signal") && this.remoteSignals.has(serviceName)) {
-              communicationTypes.push("signal");
+            if (!clientCreated) {
+              emit("meta.service_registry.dependee_registered", {
+                serviceName,
+                serviceInstanceId: uuid5,
+                serviceTransportId: trackedTransport.uuid,
+                serviceOrigin: trackedTransport.origin,
+                transportProtocols: trackedTransport.protocols,
+                communicationTypes
+              });
+              this.markTransportClientCreated(
+                trackedInstance,
+                trackedTransport.uuid
+              );
             }
-            emit("meta.service_registry.dependee_registered", {
+          } else {
+            emit("meta.service_registry.routeable_transport_missing", {
               serviceName,
-              serviceInstanceId: uuid4,
-              serviceAddress: address,
-              servicePort: port,
-              protocol: exposed ? "https" : "http",
-              communicationTypes
-            });
-            instances?.filter(
-              (i) => i.address === address && i.port === port && i.isActive
-            ).forEach((i) => {
-              i.clientCreated = true;
+              serviceInstanceId: uuid5,
+              requiredRole: this.getRoutingTransportRole(),
+              isFrontend: this.isFrontend
             });
           }
         }
@@ -815,6 +998,81 @@ var ServiceRegistry = class _ServiceRegistry {
       "meta.socket_shutdown_requested",
       "meta.fetch.destroy_requested"
     );
+    this.handleTransportUpdateTask = CadenzaService.createMetaTask(
+      "Handle Transport Update",
+      (ctx, emit) => {
+        const transport = normalizeServiceTransportDescriptor(
+          ctx.serviceTransport ?? ctx.data ?? ctx.queryData?.data ?? ctx
+        );
+        if (!transport) {
+          return false;
+        }
+        let ownerInstance;
+        for (const instances of this.instances.values()) {
+          ownerInstance = instances.find(
+            (instance) => instance.uuid === transport.serviceInstanceId
+          );
+          if (ownerInstance) {
+            break;
+          }
+        }
+        if (!ownerInstance) {
+          return false;
+        }
+        if (transport.deleted) {
+          ownerInstance.transports = ownerInstance.transports.filter(
+            (existingTransport2) => existingTransport2.uuid !== transport.uuid
+          );
+          const transportKey = buildTransportClientKey(transport);
+          emit(`meta.socket_shutdown_requested:${transportKey}`, {});
+          emit(`meta.fetch.destroy_requested:${transportKey}`, {});
+          return true;
+        }
+        const existingTransport = this.getTransportById(ownerInstance, transport.uuid);
+        if (existingTransport) {
+          Object.assign(existingTransport, transport);
+        } else {
+          ownerInstance.transports.push(transport);
+        }
+        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();
+        if (!hasRemoteInterest) {
+          return true;
+        }
+        if (!this.hasTransportClientCreated(ownerInstance, transport.uuid)) {
+          const communicationTypes = Array.from(
+            new Set(
+              this.deputies.get(ownerInstance.serviceName)?.map((descriptor) => descriptor.communicationType) ?? []
+            )
+          );
+          if (!communicationTypes.includes("signal") && this.remoteSignals.has(ownerInstance.serviceName)) {
+            communicationTypes.push("signal");
+          }
+          emit("meta.service_registry.dependee_registered", {
+            serviceName: ownerInstance.serviceName,
+            serviceInstanceId: ownerInstance.uuid,
+            serviceTransportId: transport.uuid,
+            serviceOrigin: transport.origin,
+            transportProtocols: transport.protocols,
+            communicationTypes
+          });
+          this.markTransportClientCreated(ownerInstance, transport.uuid);
+        }
+        return true;
+      },
+      "Handles service transport updates independently from instance rows."
+    ).doOn(
+      "global.meta.service_instance_transport.inserted",
+      "global.meta.service_instance_transport.updated",
+      "meta.service_instance_transport.inserted",
+      "meta.service_instance_transport.updated"
+    ).attachSignal(
+      "meta.service_registry.dependee_registered",
+      "meta.socket_shutdown_requested",
+      "meta.fetch.destroy_requested"
+    );
     CadenzaService.createMetaTask(
       "Track dependee registration",
       (ctx) => {
@@ -910,17 +1168,25 @@ var ServiceRegistry = class _ServiceRegistry {
     this.handleServiceNotRespondingTask = CadenzaService.createMetaTask(
       "Handle service not responding",
       (ctx, emit) => {
-        const { serviceName, serviceAddress, servicePort } = ctx;
+        const { serviceName, serviceInstanceId, serviceTransportId } = ctx;
         const serviceInstances = this.instances.get(serviceName);
-        const instances = serviceInstances?.filter(
-          (i) => i.address === serviceAddress && i.port === servicePort
-        );
+        const instances = serviceInstances?.filter((instance) => {
+          if (serviceInstanceId && instance.uuid === serviceInstanceId) {
+            return true;
+          }
+          if (serviceTransportId) {
+            return instance.transports.some(
+              (transport) => transport.uuid === serviceTransportId
+            );
+          }
+          return false;
+        });
         CadenzaService.log(
           "Service not responding.",
           {
             serviceName,
-            serviceAddress,
-            servicePort,
+            serviceInstanceId,
+            serviceTransportId,
             instances
           },
           "warning",
@@ -961,7 +1227,7 @@ var ServiceRegistry = class _ServiceRegistry {
     this.handleServiceHandshakeTask = CadenzaService.createMetaTask(
       "Handle service handshake",
       (ctx, emit) => {
-        const { serviceName, serviceInstanceId, serviceAddress, servicePort } = ctx;
+        const { serviceName, serviceInstanceId } = ctx;
         const serviceInstances = this.instances.get(serviceName);
         const instance = serviceInstances?.find(
           (i) => i.uuid === serviceInstanceId
@@ -989,26 +1255,6 @@ var ServiceRegistry = class _ServiceRegistry {
             uuid: instance.uuid
           }
         });
-        const instancesToDelete = serviceInstances?.filter(
-          (i) => i.uuid !== serviceInstanceId && i.address === serviceAddress && i.port === servicePort
-        );
-        for (const i of instancesToDelete ?? []) {
-          const indexToDelete = this.instances.get(serviceName)?.indexOf(i) ?? -1;
-          if (indexToDelete >= 0) {
-            this.instances.get(serviceName)?.splice(indexToDelete, 1);
-          }
-          this.unregisterDependee(i.uuid, serviceName);
-          emit("global.meta.service_registry.deleted", {
-            data: {
-              isActive: false,
-              isNonResponsive: false,
-              deleted: true
-            },
-            filter: {
-              uuid: i.uuid
-            }
-          });
-        }
         return true;
       },
       "Handles service handshake"
@@ -1027,16 +1273,13 @@ var ServiceRegistry = class _ServiceRegistry {
           return false;
         }
         let applied = this.applyRuntimeStatusReport(report);
-        if (!applied && report.serviceAddress && typeof report.servicePort === "number") {
+        if (!applied && report.transportId && report.transportOrigin) {
           if (!this.instances.has(report.serviceName)) {
             this.instances.set(report.serviceName, []);
           }
           this.instances.get(report.serviceName).push({
             uuid: report.serviceInstanceId,
             serviceName: report.serviceName,
-            address: report.serviceAddress,
-            port: report.servicePort,
-            exposed: !!report.exposed,
             isFrontend: !!report.isFrontend,
             isActive: report.isActive,
             isNonResponsive: report.isNonResponsive,
@@ -1046,7 +1289,18 @@ var ServiceRegistry = class _ServiceRegistry {
             acceptingWork: report.acceptingWork,
             reportedAt: report.reportedAt,
             health: report.health ?? {},
-            isPrimary: false
+            isPrimary: false,
+            transports: [
+              {
+                uuid: report.transportId,
+                serviceInstanceId: report.serviceInstanceId,
+                role: this.getRoutingTransportRole(),
+                origin: report.transportOrigin,
+                protocols: report.transportProtocols && report.transportProtocols.length > 0 ? report.transportProtocols : ["rest", "socket"],
+                securityProfile: null,
+                authStrategy: null
+              }
+            ]
           });
           applied = true;
         }
@@ -1087,21 +1341,9 @@ var ServiceRegistry = class _ServiceRegistry {
             deleted: !!m.deleted
           })
         );
-        const serviceInstances = (inquiryResult.serviceInstances ?? []).filter(
-          (instance) => !instance.deleted && !!instance.isActive && !instance.isNonResponsive && !instance.isBlocked
-        ).map((instance) => ({
-          uuid: instance.uuid,
-          address: instance.address,
-          port: instance.port,
-          serviceName: instance.serviceName,
-          isActive: !!instance.isActive,
-          isNonResponsive: !!instance.isNonResponsive,
-          isBlocked: !!instance.isBlocked,
-          health: instance.health ?? {},
-          exposed: !!instance.exposed,
-          created: instance.created,
-          isFrontend: !!instance.isFrontend
-        }));
+        const serviceInstances = (inquiryResult.serviceInstances ?? []).map((instance) => normalizeServiceInstanceDescriptor(instance)).filter(
+          (instance) => !!instance && !!instance.isActive && !instance.isNonResponsive && !instance.isBlocked
+        );
         return {
           ...ctx,
           signalToTaskMaps,
@@ -1188,7 +1430,19 @@ var ServiceRegistry = class _ServiceRegistry {
         const { __serviceName, __triedInstances, __retries, __broadcast } = context;
         let retries = __retries ?? 0;
         let triedInstances = __triedInstances ?? [];
-        const instances = this.instances.get(__serviceName)?.filter((i) => i.isActive && !i.isNonResponsive && !i.isBlocked).sort((a, b) => {
+        const preferredRole = this.getRoutingTransportRole();
+        const instances = this.instances.get(__serviceName)?.filter((instance) => {
+          if (!instance.isActive || instance.isNonResponsive || instance.isBlocked) {
+            return false;
+          }
+          return Boolean(
+            this.getRouteableTransport(
+              instance,
+              this.useSocket ? "socket" : "rest",
+              preferredRole
+            ) ?? this.getRouteableTransport(instance, "rest", preferredRole)
+          );
+        }).sort((a, b) => {
           const leftStatus = this.resolveRuntimeStatusSnapshot(
             a.numberOfRunningGraphs ?? 0,
             a.isActive,
@@ -1209,9 +1463,7 @@ var ServiceRegistry = class _ServiceRegistry {
         });
         if (!instances || instances.length === 0 || retries > this.retryCount) {
           context.errored = true;
-          context.__error = `No active instances for ${__serviceName}. Retries: ${retries}. ${this.instances.get(
-            __serviceName
-          )}`;
+          context.__error = this.isFrontend && preferredRole === "public" ? `No public transport available for ${__serviceName}.` : `No routeable ${preferredRole} transport available for ${__serviceName}. Retries: ${retries}.`;
           emit(
             `meta.service_registry.load_balance_failed:${context.__metadata.__deputyExecId}`,
             context
@@ -1220,10 +1472,21 @@ var ServiceRegistry = class _ServiceRegistry {
         }
         if (__broadcast || instances[0].isFrontend) {
           for (const instance of instances) {
-            const socketKey = instance.isFrontend ? instance.address : `${instance.address}_${instance.port}`;
+            const selectedTransport2 = this.getRouteableTransport(instance, "socket", preferredRole) ?? this.getRouteableTransport(instance, "rest", preferredRole);
+            if (!selectedTransport2) {
+              continue;
+            }
+            const transportKey = buildTransportClientKey(selectedTransport2);
             emit(
-              `meta.service_registry.selected_instance_for_socket:${socketKey}`,
-              context
+              `${this.useSocket && transportSupportsProtocol(selectedTransport2, "socket") ? "meta.service_registry.selected_instance_for_socket" : "meta.service_registry.selected_instance_for_fetch"}:${transportKey}`,
+              {
+                ...context,
+                __instance: instance.uuid,
+                __transportId: selectedTransport2.uuid,
+                __transportOrigin: selectedTransport2.origin,
+                __transportProtocols: selectedTransport2.protocols,
+                __fetchId: transportKey
+              }
             );
           }
           return context;
@@ -1246,12 +1509,25 @@ var ServiceRegistry = class _ServiceRegistry {
         if (retries > 0) {
           selected = instancesToTry[Math.floor(Math.random() * instancesToTry.length)];
         }
+        const selectedTransport = this.getRouteableTransport(selected, "socket", preferredRole) ?? this.getRouteableTransport(selected, "rest", preferredRole);
+        if (!selectedTransport) {
+          context.errored = true;
+          context.__error = `No routeable ${preferredRole} transport available for ${selected.serviceName}/${selected.uuid}.`;
+          emit(
+            `meta.service_registry.load_balance_failed:${context.__metadata.__deputyExecId}`,
+            context
+          );
+          return context;
+        }
         context.__instance = selected.uuid;
-        context.__fetchId = `${selected.address}_${selected.port}`;
+        context.__transportId = selectedTransport.uuid;
+        context.__transportOrigin = selectedTransport.origin;
+        context.__transportProtocols = selectedTransport.protocols;
+        context.__fetchId = buildTransportClientKey(selectedTransport);
         context.__triedInstances = triedInstances;
         context.__triedInstances.push(selected.uuid);
         context.__retries = retries;
-        if (this.useSocket) {
+        if (this.useSocket && transportSupportsProtocol(selectedTransport, "socket")) {
           emit(
             `meta.service_registry.selected_instance_for_socket:${context.__fetchId}`,
             context
@@ -1443,9 +1719,9 @@ var ServiceRegistry = class _ServiceRegistry {
           __active: report.isActive,
           serviceName: report.serviceName,
           serviceInstanceId: report.serviceInstanceId,
-          serviceAddress: report.serviceAddress,
-          servicePort: report.servicePort,
-          exposed: report.exposed,
+          transportId: report.transportId,
+          transportOrigin: report.transportOrigin,
+          transportProtocols: report.transportProtocols,
           isFrontend: report.isFrontend,
           reportedAt: report.reportedAt,
           numberOfRunningGraphs: report.numberOfRunningGraphs,
@@ -1488,12 +1764,17 @@ var ServiceRegistry = class _ServiceRegistry {
               continue;
             }
             this.runtimeStatusFallbackInFlightByInstance.add(serviceInstanceId);
+            const transport = this.getRouteableTransport(
+              instance,
+              this.useSocket ? "socket" : "rest"
+            );
             emit("meta.service_registry.runtime_status_fallback_requested", {
               ...ctx,
               serviceName,
               serviceInstanceId,
-              serviceAddress: instance.address,
-              servicePort: instance.port
+              serviceTransportId: transport?.uuid,
+              serviceOrigin: transport?.origin,
+              transportProtocols: transport?.protocols
             });
           }
         }
@@ -1527,6 +1808,10 @@ var ServiceRegistry = class _ServiceRegistry {
           };
         } catch (error) {
           const instance = this.getInstance(serviceName, serviceInstanceId);
+          const transport = instance ? this.getRouteableTransport(
+            instance,
+            this.useSocket ? "socket" : "rest"
+          ) : void 0;
           const message = error instanceof Error ? error.message : String(error);
           CadenzaService.log(
             "Runtime status fallback inquiry failed.",
@@ -1541,8 +1826,9 @@ var ServiceRegistry = class _ServiceRegistry {
             ...ctx,
             serviceName,
             serviceInstanceId,
-            serviceAddress: instance?.address ?? ctx.serviceAddress,
-            servicePort: instance?.port ?? ctx.servicePort,
+            serviceTransportId: transport?.uuid ?? ctx.serviceTransportId,
+            serviceOrigin: transport?.origin ?? ctx.serviceOrigin,
+            transportProtocols: transport?.protocols ?? ctx.transportProtocols,
             __error: message,
             errored: true
           });
@@ -1655,85 +1941,185 @@ var ServiceRegistry = class _ServiceRegistry {
         inputSchema: {
           type: "object",
           properties: {
-            uuid: {
-              type: "string"
-            },
-            address: {
-              type: "string"
-            },
-            port: {
-              type: "number"
-            },
-            process_pid: {
-              type: "number"
-            },
-            is_primary: {
-              type: "boolean"
-            },
-            service_name: {
-              type: "string"
-            },
-            is_active: {
-              type: "boolean"
-            },
-            is_non_responsive: {
-              type: "boolean"
-            },
-            is_blocked: {
-              type: "boolean"
-            },
-            exposed: {
-              type: "boolean"
+            data: {
+              type: "object",
+              properties: {
+                uuid: {
+                  type: "string"
+                },
+                process_pid: {
+                  type: "number"
+                },
+                is_primary: {
+                  type: "boolean"
+                },
+                service_name: {
+                  type: "string"
+                },
+                is_active: {
+                  type: "boolean"
+                },
+                is_frontend: {
+                  type: "boolean"
+                },
+                is_database: {
+                  type: "boolean"
+                },
+                is_non_responsive: {
+                  type: "boolean"
+                },
+                is_blocked: {
+                  type: "boolean"
+                },
+                health: {
+                  type: "object"
+                }
+              },
+              required: ["uuid", "process_pid", "service_name"]
             }
           },
-          required: [
-            "id",
-            "address",
-            "port",
-            "process_pid",
-            "service_name",
-            "exposed"
-          ]
+          required: ["data"]
         },
-        // validateInputContext: true,
         outputSchema: {
           type: "object",
           properties: {
-            id: {
+            uuid: {
               type: "string"
             }
           },
-          required: ["id"]
+          required: ["uuid"]
         },
-        // validateOutputContext: true,
         retryCount: 5,
         retryDelay: 1e3
       }
-    ).doOn("global.meta.rest.network_configured", "meta.rest.browser_detected").then(
+    ).doOn("meta.service_registry.instance_registration_requested").then(
       CadenzaService.createMetaTask(
         "Setup service",
         (ctx) => {
-          const { serviceInstance, data, __useSocket, __retryCount } = ctx;
-          this.serviceInstanceId = serviceInstance?.uuid ?? data?.uuid;
+          const {
+            serviceInstance,
+            data,
+            queryData,
+            __useSocket,
+            __retryCount,
+            __isFrontend
+          } = ctx;
+          const normalizedLocalInstance = normalizeServiceInstanceDescriptor({
+            ...serviceInstance ?? data ?? queryData?.data ?? {},
+            transports: ctx.transportData ?? []
+          });
+          if (!normalizedLocalInstance?.uuid || !normalizedLocalInstance.serviceName) {
+            return false;
+          }
+          this.serviceInstanceId = normalizedLocalInstance.uuid;
           this.instances.set(
-            data?.service_name ?? serviceInstance?.service_name,
-            [{ ...serviceInstance ?? data }]
+            normalizedLocalInstance.serviceName,
+            [{ ...normalizedLocalInstance }]
           );
           this.useSocket = __useSocket;
           this.retryCount = __retryCount;
+          this.isFrontend = typeof __isFrontend === "boolean" ? __isFrontend : !!normalizedLocalInstance.isFrontend;
           console.log("SETUP SERVICE", this.serviceInstanceId);
           return true;
         },
         "Sets service instance id after insertion"
-      ).emits("meta.service_registry.instance_inserted")
+      ).emits("meta.service_registry.instance_inserted").then(
+        CadenzaService.createMetaTask(
+          "Prepare service transport inserts",
+          function* (ctx, emit) {
+            const transportData = Array.isArray(ctx.transportData) ? ctx.transportData : [];
+            for (const transport of transportData) {
+              const transportContext = {
+                ...ctx,
+                data: {
+                  ...transport,
+                  service_instance_id: transport.service_instance_id ?? ctx.__serviceInstanceId
+                }
+              };
+              emit(
+                "meta.service_registry.transport_registration_requested",
+                transportContext
+              );
+              yield transportContext;
+            }
+          },
+          "Splits declared service transports into individual insert payloads."
+        ).attachSignal("meta.service_registry.transport_registration_requested")
+      )
     );
+    this.insertServiceTransportTask = CadenzaService.createCadenzaDBInsertTask(
+      "service_instance_transport",
+      {
+        onConflict: {
+          target: ["service_instance_id", "role", "origin"],
+          action: {
+            do: "update",
+            set: {
+              protocols: "excluded",
+              security_profile: "excluded",
+              auth_strategy: "excluded",
+              deleted: "false"
+            }
+          }
+        }
+      },
+      {
+        inputSchema: {
+          type: "object",
+          properties: {
+            data: {
+              type: "object",
+              properties: {
+                uuid: {
+                  type: "string"
+                },
+                service_instance_id: {
+                  type: "string"
+                },
+                role: {
+                  type: "string"
+                },
+                origin: {
+                  type: "string"
+                },
+                protocols: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                security_profile: {
+                  type: "string"
+                },
+                auth_strategy: {
+                  type: "string"
+                }
+              },
+              required: ["uuid", "service_instance_id", "role", "origin"]
+            }
+          },
+          required: ["data"]
+        },
+        outputSchema: {
+          type: "object",
+          properties: {
+            uuid: {
+              type: "string"
+            }
+          },
+          required: ["uuid"]
+        },
+        retryCount: 5,
+        retryDelay: 1e3
+      }
+    ).doOn("meta.service_registry.transport_registration_requested").emits("meta.service_registry.transport_registered").emitsOnFail("meta.service_registry.transport_registration_failed");
     CadenzaService.createMetaTask(
       "Handle service creation",
       (ctx) => {
         if (!ctx.__cadenzaDBConnect) {
           ctx.__skipRemoteExecution = true;
         }
-        if (isBrowser) {
+        if (isBrowser || ctx.__isFrontend) {
           CadenzaService.createMetaTask("Prepare for signal sync", () => {
             return {};
           }).then(
@@ -1766,28 +2152,24 @@ var ServiceRegistry = class _ServiceRegistry {
                   for (const service of services) {
                     const instances = this.instances.get(service).filter((i) => i.isActive);
                     for (const instance of instances) {
-                      if (instance.clientCreated) continue;
-                      const address = instance.address;
-                      const port = instance.port;
-                      const clientCreated = instances?.some(
-                        (i) => i.address === address && i.port === port && i.clientCreated && i.isActive
+                      const transport = this.getRouteableTransport(
+                        instance,
+                        this.useSocket ? "socket" : "rest"
                       );
-                      if (!clientCreated) {
+                      if (!transport) {
+                        continue;
+                      }
+                      if (!this.hasTransportClientCreated(instance, transport.uuid)) {
                         emit("meta.service_registry.dependee_registered", {
                           serviceName: service,
                           serviceInstanceId: instance.uuid,
-                          serviceAddress: address,
-                          servicePort: port,
-                          protocol: instance.exposed ? "https" : "http",
+                          serviceTransportId: transport.uuid,
+                          serviceOrigin: transport.origin,
+                          transportProtocols: transport.protocols,
                           communicationTypes: ["signal"]
                         });
+                        this.markTransportClientCreated(instance, transport.uuid);
                       }
-                      instance.clientCreated = true;
-                      instances.forEach((i) => {
-                        if (i.address === address && i.port === port) {
-                          i.clientCreated = true;
-                        }
-                      });
                     }
                   }
                   return {};
@@ -1926,6 +2308,33 @@ var ServiceRegistry = class _ServiceRegistry {
     }
     return this.getInstance(this.serviceName, this.serviceInstanceId);
   }
+  getRoutingTransportRole() {
+    return this.isFrontend ? "public" : "internal";
+  }
+  getTransportById(instance, transportId) {
+    return instance.transports.find((transport) => transport.uuid === transportId);
+  }
+  getRouteableTransport(instance, protocol, role = this.getRoutingTransportRole()) {
+    return getRouteableTransport(instance, role, protocol);
+  }
+  getTransportClientKey(instance, protocol, role = this.getRoutingTransportRole()) {
+    const transport = this.getRouteableTransport(instance, protocol, role);
+    if (!transport) {
+      return null;
+    }
+    return buildTransportClientKey(transport);
+  }
+  hasTransportClientCreated(instance, transportId) {
+    return (instance.clientCreatedTransportIds ?? []).includes(transportId);
+  }
+  markTransportClientCreated(instance, transportId) {
+    if (!instance.clientCreatedTransportIds) {
+      instance.clientCreatedTransportIds = [];
+    }
+    if (!instance.clientCreatedTransportIds.includes(transportId)) {
+      instance.clientCreatedTransportIds.push(transportId);
+    }
+  }
   registerDependee(serviceName, serviceInstanceId, options = {}) {
     if (!serviceName || !serviceInstanceId) {
       return;
@@ -2003,7 +2412,13 @@ var ServiceRegistry = class _ServiceRegistry {
     if (!serviceName || !serviceInstanceId) {
       return null;
     }
-    const servicePort = ctx.servicePort ?? ctx.port ?? ctx.serviceInstance?.port;
+    const transportId = ctx.transportId ?? ctx.serviceTransportId ?? ctx.serviceTransport?.uuid ?? void 0;
+    const transportOrigin = ctx.transportOrigin ?? ctx.serviceOrigin ?? ctx.serviceTransport?.origin ?? void 0;
+    const transportProtocols = Array.isArray(
+      ctx.transportProtocols ?? ctx.serviceTransport?.protocols
+    ) ? (ctx.transportProtocols ?? ctx.serviceTransport?.protocols).map((entry) => String(entry)).filter(
+      (entry) => entry === "rest" || entry === "socket"
+    ) : void 0;
     const numberOfRunningGraphs = Math.max(
       0,
       Math.trunc(
@@ -2022,9 +2437,9 @@ var ServiceRegistry = class _ServiceRegistry {
     return {
       serviceName,
       serviceInstanceId,
-      serviceAddress: ctx.serviceAddress ?? ctx.address ?? ctx.serviceInstance?.address,
-      servicePort: typeof servicePort === "number" ? servicePort : void 0,
-      exposed: typeof ctx.exposed === "boolean" ? ctx.exposed : typeof ctx.serviceInstance?.exposed === "boolean" ? ctx.serviceInstance.exposed : void 0,
+      transportId: typeof transportId === "string" && transportId.trim().length > 0 ? transportId : void 0,
+      transportOrigin: typeof transportOrigin === "string" && transportOrigin.trim().length > 0 ? transportOrigin : void 0,
+      transportProtocols: transportProtocols && transportProtocols.length > 0 ? Array.from(new Set(transportProtocols)) : void 0,
       isFrontend: typeof ctx.isFrontend === "boolean" ? ctx.isFrontend : typeof ctx.serviceInstance?.isFrontend === "boolean" ? ctx.serviceInstance.isFrontend : void 0,
       reportedAt: ctx.reportedAt ?? (typeof ctx.__reportedAt === "string" ? ctx.__reportedAt : void 0) ?? (/* @__PURE__ */ new Date()).toISOString(),
       state: ctx.state === "healthy" || ctx.state === "degraded" || ctx.state === "overloaded" || ctx.state === "unavailable" ? ctx.state : resolved.state,
@@ -2041,14 +2456,23 @@ var ServiceRegistry = class _ServiceRegistry {
     if (!instance) {
       return false;
     }
-    if (report.serviceAddress) {
-      instance.address = report.serviceAddress;
-    }
-    if (typeof report.servicePort === "number") {
-      instance.port = report.servicePort;
-    }
-    if (typeof report.exposed === "boolean") {
-      instance.exposed = report.exposed;
+    if (report.transportId && report.transportOrigin) {
+      const protocols = report.transportProtocols && report.transportProtocols.length > 0 ? report.transportProtocols : ["rest", "socket"];
+      const existingTransport = this.getTransportById(instance, report.transportId);
+      if (existingTransport) {
+        existingTransport.origin = report.transportOrigin;
+        existingTransport.protocols = protocols;
+      } else {
+        instance.transports.push({
+          uuid: report.transportId,
+          serviceInstanceId: report.serviceInstanceId,
+          role: this.getRoutingTransportRole(),
+          origin: report.transportOrigin,
+          protocols,
+          securityProfile: null,
+          authStrategy: null
+        });
+      }
     }
     if (typeof report.isFrontend === "boolean") {
       instance.isFrontend = report.isFrontend;
@@ -2091,9 +2515,21 @@ var ServiceRegistry = class _ServiceRegistry {
     const report = {
       serviceName: this.serviceName,
       serviceInstanceId: this.serviceInstanceId,
-      serviceAddress: localInstance.address,
-      servicePort: localInstance.port,
-      exposed: localInstance.exposed,
+      transportId: this.getRouteableTransport(
+        localInstance,
+        this.useSocket ? "socket" : "rest",
+        "internal"
+      )?.uuid ?? void 0,
+      transportOrigin: this.getRouteableTransport(
+        localInstance,
+        this.useSocket ? "socket" : "rest",
+        "internal"
+      )?.origin ?? void 0,
+      transportProtocols: this.getRouteableTransport(
+        localInstance,
+        this.useSocket ? "socket" : "rest",
+        "internal"
+      )?.protocols ?? void 0,
       isFrontend: localInstance.isFrontend,
       reportedAt,
       state: snapshot.state,
@@ -2308,6 +2744,7 @@ var ServiceRegistry = class _ServiceRegistry {
     this.numberOfRunningGraphs = 0;
     this.runtimeStatusHeartbeatStarted = false;
     this.lastRuntimeStatusSnapshot = null;
+    this.isFrontend = false;
   }
 };
 
@@ -2479,13 +2916,10 @@ var RestController = class _RestController {
         CadenzaService.createMetaTask(
           "Setup Express app security",
           (ctx, emit) => {
-            if (isBrowser) {
-              emit("meta.rest.browser_detected", {
+            if (isBrowser || ctx.__isFrontend) {
+              emit("meta.service_registry.instance_registration_requested", {
                 data: {
                   uuid: ctx.__serviceInstanceId,
-                  address: `browser:${ctx.__serviceInstanceId}`,
-                  port: 0,
-                  exposed: false,
                   process_pid: 1,
                   service_name: ctx.__serviceName,
                   is_frontend: true,
@@ -2494,6 +2928,7 @@ var RestController = class _RestController {
                   is_blocked: false,
                   health: {}
                 },
+                transportData: [],
                 ...ctx
               });
               return;
@@ -2566,7 +3001,7 @@ var RestController = class _RestController {
             return { ...ctx, __app: app };
           },
           "Sets up the Express server according to the security profile"
-        ).attachSignal("meta.rest.browser_detected").then(
+        ).attachSignal("meta.service_registry.instance_registration_requested").then(
           CadenzaService.createMetaTask(
             "Define RestServer",
             (ctx) => {
@@ -2686,28 +3121,32 @@ var RestController = class _RestController {
             CadenzaService.createMetaTask(
               "Configure network",
               async (ctx) => {
-                let address = "undefined";
-                let port = ctx.__port;
-                let exposed = false;
-                const createHttpServer = async (ctx2) => {
-                  await new Promise((resolve) => {
+                let httpOrigin = null;
+                let httpsOrigin = null;
+                const resolveBoundAddress = (server) => {
+                  if (typeof server?.address() === "string") {
+                    return server.address();
+                  }
+                  if (server?.address()?.address === "::") {
+                    if (process.env.NODE_ENV === "development") {
+                      return "localhost";
+                    }
+                    if (process.env.IS_DOCKER === "true") {
+                      return process.env.CADENZA_SERVER_URL || "localhost";
+                    }
+                  }
+                  return server?.address()?.address || "localhost";
+                };
+                const createHttpServer = async (ctx2) => {
+                  await new Promise((resolve) => {
                     const server = http.createServer(ctx2.__app);
                     ctx2.httpServer = server;
                     server.listen(ctx2.__port, () => {
-                      if (typeof server?.address() === "string") {
-                        address = server.address();
-                      } else if (server?.address()?.address === "::") {
-                        if (process.env.NODE_ENV === "development") {
-                          address = "localhost";
-                        } else if (process.env.IS_DOCKER === "true") {
-                          address = process.env.CADENZA_SERVER_URL || "localhost";
-                        }
-                      } else {
-                        address = server?.address()?.address || "undefined";
-                      }
-                      console.log(
-                        `Server is running on ${address}:${port}`
-                      );
+                      const addressInfo = server.address();
+                      const address = resolveBoundAddress(server);
+                      const port = typeof addressInfo === "object" && addressInfo ? addressInfo.port || ctx2.__port : ctx2.__port;
+                      httpOrigin = `http://${address}:${port}`;
+                      console.log(`Server is running on ${httpOrigin}`);
                       resolve(address);
                     });
                     CadenzaService.createMetaTask(
@@ -2733,22 +3172,12 @@ var RestController = class _RestController {
                       ctx2.__app
                     );
                     ctx2.httpsServer = httpsServer;
-                    ctx2.__port = 443;
-                    port = 443;
                     httpsServer.listen(443, () => {
-                      if (typeof httpsServer?.address() === "string") {
-                        address = httpsServer.address();
-                      } else if (httpsServer?.address()?.address === "::") {
-                        if (process.env.IS_DOCKER === "true") {
-                          address = process.env.CADENZA_SERVER_URL || "localhost";
-                        }
-                      } else {
-                        address = httpsServer?.address()?.address || "";
-                      }
-                      exposed = true;
-                      console.log(
-                        `HTTPS Server is running on ${address}:443`
-                      );
+                      const addressInfo = httpsServer.address();
+                      const address = resolveBoundAddress(httpsServer);
+                      const port = typeof addressInfo === "object" && addressInfo ? addressInfo.port || 443 : 443;
+                      httpsOrigin = `https://${address}:${port}`;
+                      console.log(`HTTPS Server is running on ${httpsOrigin}`);
                       resolve(address);
                     });
                     CadenzaService.createMetaTask(
@@ -2768,11 +3197,34 @@ var RestController = class _RestController {
                 } else if (ctx.__networkMode === "auto") {
                   await createHttpServer(ctx);
                 }
+                const declaredTransports = Array.isArray(ctx.__declaredTransports) ? ctx.__declaredTransports : [];
+                const hasExplicitInternalTransport = declaredTransports.some(
+                  (transport) => transport.role === "internal"
+                );
+                const transportData = declaredTransports.map((transport) => ({
+                  uuid: transport.uuid,
+                  service_instance_id: ctx.__serviceInstanceId,
+                  role: transport.role,
+                  origin: transport.origin,
+                  protocols: transport.protocols ?? ["rest", "socket"],
+                  ...transport.securityProfile ? { security_profile: transport.securityProfile } : {},
+                  ...transport.authStrategy ? { auth_strategy: transport.authStrategy } : {}
+                }));
+                if (!hasExplicitInternalTransport) {
+                  const internalOrigin = httpOrigin ?? httpsOrigin;
+                  if (internalOrigin) {
+                    transportData.unshift({
+                      uuid: `${ctx.__serviceInstanceId}-internal-auto`,
+                      service_instance_id: ctx.__serviceInstanceId,
+                      role: "internal",
+                      origin: internalOrigin,
+                      protocols: ["rest", "socket"],
+                      ...ctx.__securityProfile ? { security_profile: ctx.__securityProfile } : {}
+                    });
+                  }
+                }
                 ctx.data = {
                   uuid: ctx.__serviceInstanceId,
-                  address,
-                  port,
-                  exposed,
                   process_pid: process.pid,
                   service_name: ctx.__serviceName,
                   is_active: true,
@@ -2781,7 +3233,12 @@ var RestController = class _RestController {
                   is_blocked: false,
                   health: {}
                 };
+                ctx.transportData = transportData;
                 delete ctx.__app;
+                CadenzaService.emit(
+                  "meta.service_registry.instance_registration_requested",
+                  ctx
+                );
                 return ctx;
               },
               "Configures network mode"
@@ -2831,10 +3288,12 @@ var RestController = class _RestController {
     CadenzaService.createMetaTask(
       "Setup fetch client",
       (ctx) => {
-        const { serviceName, serviceAddress, servicePort, protocol } = ctx;
-        const port = protocol === "https" ? 443 : servicePort;
-        const URL2 = `${protocol}://${serviceAddress}:${port}`;
-        const fetchId = `${serviceAddress}_${port}`;
+        const serviceName = String(ctx.serviceName ?? "");
+        const URL2 = String(ctx.serviceOrigin ?? "");
+        const fetchId = String(ctx.serviceTransportId ?? "");
+        if (!serviceName || !URL2 || !fetchId) {
+          return false;
+        }
         const fetchDiagnostics = this.ensureFetchClientDiagnostics(
           fetchId,
           serviceName,
@@ -3086,18 +3545,18 @@ var RestController = class _RestController {
             serviceName,
             serviceInstanceId,
             communicationTypes,
-            serviceAddress,
-            servicePort,
-            protocol
+            serviceTransportId,
+            serviceOrigin,
+            transportProtocols
           } = ctx;
-          const fetchId = `${serviceAddress}_${servicePort}`;
+          const fetchId = String(serviceTransportId ?? "");
           emit(`meta.fetch.handshake_requested:${fetchId}`, {
             serviceInstanceId,
             serviceName,
             communicationTypes,
-            serviceAddress,
-            servicePort,
-            protocol,
+            serviceTransportId,
+            serviceOrigin,
+            transportProtocols,
             handshakeData: {
               instanceId: CadenzaService.serviceRegistry.serviceInstanceId,
               serviceName: CadenzaService.serviceRegistry.serviceName
@@ -3280,7 +3739,6 @@ var RestController = class _RestController {
 };
 
 // src/network/SocketController.ts
-import { Server } from "socket.io";
 import { RateLimiterMemory as RateLimiterMemory2 } from "rate-limiter-flexible";
 import { io } from "socket.io-client";
 
@@ -3323,6 +3781,13 @@ var waitForSocketConnection = async (socket, timeoutMs, createError) => {
 };
 
 // src/network/SocketController.ts
+var dynamicImport = new Function(
+  "specifier",
+  "return import(specifier);"
+);
+async function importNodeModule(specifier) {
+  return dynamicImport(specifier);
+}
 var SocketController = class _SocketController {
   constructor() {
     this.diagnosticsErrorHistoryLimit = 100;
@@ -3347,9 +3812,9 @@ var SocketController = class _SocketController {
       serviceInstanceId: "",
       communicationTypes: [],
       serviceName: "",
-      serviceAddress: "",
-      servicePort: 0,
-      protocol: "http",
+      serviceTransportId: "",
+      serviceOrigin: "",
+      transportProtocols: [],
       url: "",
       socketId: null,
       connected: false,
@@ -3522,7 +3987,7 @@ var SocketController = class _SocketController {
     const setupSocketServerTask = CadenzaService.createMetaTask(
       "Setup SocketServer",
       this.socketServerActor.task(
-        ({ state, runtimeState, input, actor, setState, setRuntimeState, emit }) => {
+        async ({ state, runtimeState, input, actor, setState, setRuntimeState, emit }) => {
           const serverKey = this.resolveSocketServerKey(input) ?? actor.key ?? this.socketServerDefaultKey;
           const shouldUseSocket = Boolean(input.__useSocket);
           if (!shouldUseSocket) {
@@ -3541,7 +4006,9 @@ var SocketController = class _SocketController {
           }
           let runtimeHandle = runtimeState;
           if (!runtimeHandle) {
-            runtimeHandle = this.createSocketServerRuntimeHandleFromContext(input);
+            runtimeHandle = await this.createSocketServerRuntimeHandleFromContext(
+              input
+            );
             setRuntimeState(runtimeHandle);
           }
           const profile = String(input.__securityProfile ?? state.securityProfile ?? "medium");
@@ -3799,21 +4266,21 @@ var SocketController = class _SocketController {
           if (input.serviceName !== void 0) {
             next.serviceName = String(input.serviceName);
           }
-          if (input.serviceAddress !== void 0) {
-            next.serviceAddress = String(input.serviceAddress);
+          if (input.serviceTransportId !== void 0) {
+            next.serviceTransportId = String(input.serviceTransportId);
           }
           if (input.serviceInstanceId !== void 0) {
             next.serviceInstanceId = String(input.serviceInstanceId);
           }
-          if (input.protocol !== void 0) {
-            next.protocol = String(input.protocol);
+          if (input.serviceOrigin !== void 0) {
+            next.serviceOrigin = String(input.serviceOrigin);
+          }
+          if (input.transportProtocols !== void 0) {
+            next.transportProtocols = Array.isArray(input.transportProtocols) ? input.transportProtocols.map((entry) => String(entry)) : [];
           }
           if (input.url !== void 0) {
             next.url = String(input.url);
           }
-          if (input.servicePort !== void 0) {
-            next.servicePort = Number(input.servicePort);
-          }
           if (input.fetchId !== void 0) {
             next.fetchId = String(input.fetchId);
           }
@@ -3857,25 +4324,24 @@ var SocketController = class _SocketController {
             input.communicationTypes
           );
           const serviceName = String(input.serviceName ?? "");
-          const serviceAddress = String(input.serviceAddress ?? "");
-          const protocol = String(input.protocol ?? "http");
-          const normalizedPort = this.resolveServicePort(protocol, input.servicePort);
-          if (!serviceAddress || !normalizedPort) {
+          const serviceTransportId = String(input.serviceTransportId ?? "");
+          const serviceOrigin = String(input.serviceOrigin ?? "");
+          const parsedOrigin = parseTransportOrigin(serviceOrigin);
+          if (!serviceTransportId || !serviceOrigin || !parsedOrigin) {
             CadenzaService.log(
-              "Socket client setup skipped due to missing address/port",
+              "Socket client setup skipped due to missing transport origin",
               {
                 serviceName,
-                serviceAddress,
-                servicePort: input.servicePort,
-                protocol
+                serviceTransportId,
+                serviceOrigin
               },
               "warning"
             );
             return false;
           }
-          const socketProtocol = protocol === "https" ? "wss" : "ws";
-          const url = `${socketProtocol}://${serviceAddress}:${normalizedPort}`;
-          const fetchId = `${serviceAddress}_${normalizedPort}`;
+          const socketProtocol = parsedOrigin.protocol === "https" ? "wss" : "ws";
+          const url = `${socketProtocol}://${parsedOrigin.hostname}:${parsedOrigin.port}`;
+          const fetchId = serviceTransportId;
           const applySessionOperation = (operation, patch = {}) => {
             CadenzaService.emit("meta.socket_client.session_operation_requested", {
               fetchId,
@@ -3884,9 +4350,9 @@ var SocketController = class _SocketController {
               serviceInstanceId,
               communicationTypes,
               serviceName,
-              serviceAddress,
-              servicePort: normalizedPort,
-              protocol,
+              serviceTransportId,
+              serviceOrigin,
+              transportProtocols: input.transportProtocols,
               url
             });
           };
@@ -3905,9 +4371,9 @@ var SocketController = class _SocketController {
             serviceInstanceId,
             communicationTypes,
             serviceName,
-            serviceAddress,
-            servicePort: normalizedPort,
-            protocol,
+            serviceTransportId,
+            serviceOrigin,
+            transportProtocols: Array.isArray(input.transportProtocols) ? input.transportProtocols.map((entry) => String(entry)) : [],
             url,
             destroyed: false,
             updatedAt: Date.now()
@@ -4235,8 +4701,8 @@ var SocketController = class _SocketController {
             );
             CadenzaService.emit(`meta.socket_client.disconnected:${fetchId}`, {
               serviceName,
-              serviceAddress,
-              servicePort: normalizedPort
+              serviceTransportId,
+              serviceOrigin
             });
             runtimeHandle.handshake = false;
           });
@@ -4257,7 +4723,7 @@ var SocketController = class _SocketController {
                 {
                   serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
                   serviceName: CadenzaService.serviceRegistry.serviceName,
-                  isFrontend: isBrowser,
+                  isFrontend: CadenzaService.serviceRegistry.isFrontend || isBrowser,
                   __status: "success"
                 },
                 1e4,
@@ -4435,9 +4901,9 @@ var SocketController = class _SocketController {
                 serviceInstanceId,
                 serviceName,
                 communicationTypes,
-                serviceAddress,
-                servicePort: normalizedPort,
-                protocol,
+                serviceTransportId,
+                serviceOrigin,
+                transportProtocols: input.transportProtocols,
                 handshakeData: {
                   instanceId: CadenzaService.serviceRegistry.serviceInstanceId,
                   serviceName: CadenzaService.serviceRegistry.serviceName
@@ -4476,31 +4942,20 @@ var SocketController = class _SocketController {
     if (explicitFetchId) {
       return explicitFetchId;
     }
-    const serviceAddress = String(input.serviceAddress ?? "").trim();
-    const protocol = String(input.protocol ?? "http").trim();
-    const port = this.resolveServicePort(protocol, input.servicePort);
-    if (!serviceAddress || !port) {
-      return void 0;
-    }
-    return `${serviceAddress}_${port}`;
+    const transportId = String(
+      input.serviceTransportId ?? input.transportId ?? ""
+    ).trim();
+    return transportId || void 0;
   }
-  resolveServicePort(protocol, rawPort) {
-    if (protocol === "https") {
-      return 443;
-    }
-    const parsed = Number(rawPort);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-      return void 0;
-    }
-    return Math.trunc(parsed);
-  }
-  createSocketServerRuntimeHandleFromContext(context) {
+  async createSocketServerRuntimeHandleFromContext(context) {
     const baseServer = context.httpsServer ?? context.httpServer;
     if (!baseServer) {
       throw new Error(
         "Socket server runtime setup requires either httpsServer or httpServer"
       );
     }
+    const socketServerModule = await importNodeModule("socket.io");
+    const Server = socketServerModule.Server;
     const server = new Server(baseServer, {
       pingInterval: 3e4,
       pingTimeout: 2e4,
@@ -4799,8 +5254,132 @@ var SignalController = class _SignalController {
   }
 };
 
-// src/graph/controllers/GraphMetadataController.ts
+// src/graph/controllers/registerActorSessionPersistence.ts
 import { META_ACTOR_SESSION_STATE_PERSIST_INTENT } from "@cadenza.io/core";
+function registerActorSessionPersistenceTasks() {
+  if (CadenzaService.get("Persist actor session state")) {
+    return;
+  }
+  const actorSessionStateInsertTask = CadenzaService.get("dbInsertActorSessionState") ?? CadenzaService.get("Insert actor_session_state in CadenzaDB") ?? CadenzaService.createCadenzaDBInsertTask(
+    "actor_session_state",
+    {},
+    { concurrency: 100, isSubMeta: true }
+  );
+  const validateActorSessionStatePersistenceTask = CadenzaService.createMetaTask(
+    "Validate actor session state persistence",
+    (ctx) => {
+      if (ctx.errored || ctx.failed || ctx.__success !== true) {
+        throw new Error(
+          String(
+            ctx.__error ?? ctx.error ?? "actor_session_state persistence query failed"
+          )
+        );
+      }
+      const rowCount = Number(ctx.rowCount ?? 0);
+      if (!Number.isFinite(rowCount) || rowCount <= 0) {
+        throw new Error(
+          "actor_session_state persistence did not affect any rows (possible stale durable_version)"
+        );
+      }
+      return {
+        __success: true,
+        persisted: true,
+        actor_name: ctx.actor_name,
+        actor_version: ctx.actor_version,
+        actor_key: ctx.actor_key,
+        service_name: ctx.service_name,
+        durable_version: ctx.durable_version
+      };
+    },
+    "Enforces strict actor session persistence success contract.",
+    { isSubMeta: true, concurrency: 100 }
+  );
+  const insertAndValidateActorSessionStateTask = actorSessionStateInsertTask.then(
+    validateActorSessionStatePersistenceTask
+  );
+  CadenzaService.createMetaTask(
+    "Persist actor session state",
+    (ctx) => {
+      const actorName = typeof ctx.actor_name === "string" ? ctx.actor_name.trim() : "";
+      const actorKey = typeof ctx.actor_key === "string" ? ctx.actor_key.trim() : "";
+      const actorVersion = Number(ctx.actor_version ?? 1);
+      const durableVersion = Number(ctx.durable_version);
+      if (!actorName) {
+        throw new Error("actor_name is required for actor session persistence");
+      }
+      if (!actorKey) {
+        throw new Error("actor_key is required for actor session persistence");
+      }
+      if (!Number.isInteger(actorVersion) || actorVersion < 1) {
+        throw new Error("actor_version must be a positive integer");
+      }
+      if (!Number.isInteger(durableVersion) || durableVersion < 0) {
+        throw new Error("durable_version must be a non-negative integer");
+      }
+      if (typeof ctx.durable_state !== "object" || ctx.durable_state === null || Array.isArray(ctx.durable_state)) {
+        throw new Error("durable_state must be a non-null object");
+      }
+      const serviceName = CadenzaService.serviceRegistry.serviceName;
+      if (!serviceName) {
+        throw new Error("service_name is not available for actor session persistence");
+      }
+      let expiresAt = null;
+      if (ctx.expires_at !== void 0 && ctx.expires_at !== null) {
+        if (ctx.expires_at instanceof Date) {
+          expiresAt = ctx.expires_at.toISOString();
+        } else if (typeof ctx.expires_at === "string" && ctx.expires_at.trim().length > 0) {
+          expiresAt = ctx.expires_at;
+        } else {
+          throw new Error("expires_at must be null, Date, or non-empty string");
+        }
+      }
+      const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        ...ctx,
+        actor_name: actorName,
+        actor_key: actorKey,
+        actor_version: actorVersion,
+        durable_version: durableVersion,
+        expires_at: expiresAt,
+        service_name: serviceName,
+        queryData: {
+          data: {
+            actor_name: actorName,
+            actor_version: actorVersion,
+            actor_key: actorKey,
+            service_name: serviceName,
+            durable_state: ctx.durable_state,
+            durable_version: durableVersion,
+            expires_at: expiresAt,
+            updated: updatedAt
+          },
+          onConflict: {
+            target: [
+              "actor_name",
+              "actor_version",
+              "actor_key",
+              "service_name"
+            ],
+            action: {
+              do: "update",
+              set: {
+                durable_state: "excluded",
+                durable_version: "excluded",
+                expires_at: "excluded",
+                updated: "excluded"
+              },
+              where: "actor_session_state.durable_version <= excluded.durable_version"
+            }
+          }
+        }
+      };
+    },
+    "Validates and prepares actor_session_state payload for strict write-through persistence.",
+    { isSubMeta: true, concurrency: 100 }
+  ).then(insertAndValidateActorSessionStateTask).respondsTo(META_ACTOR_SESSION_STATE_PERSIST_INTENT);
+}
+
+// src/graph/controllers/GraphMetadataController.ts
 var GraphMetadataController = class _GraphMetadataController {
   static get instance() {
     if (!this._instance) this._instance = new _GraphMetadataController();
@@ -5034,123 +5613,7 @@ var GraphMetadataController = class _GraphMetadataController {
         }
       };
     }).doOn("meta.actor.task_associated").emits("global.meta.graph_metadata.actor_task_associated");
-    const actorSessionStateInsertTask = CadenzaService.get("dbInsertActorSessionState") ?? CadenzaService.get("Insert actor_session_state in CadenzaDB") ?? CadenzaService.createCadenzaDBInsertTask(
-      "actor_session_state",
-      {},
-      { concurrency: 100, isSubMeta: true }
-    );
-    const validateActorSessionStatePersistenceTask = CadenzaService.createMetaTask(
-      "Validate actor session state persistence",
-      (ctx) => {
-        if (ctx.errored || ctx.failed || ctx.__success !== true) {
-          throw new Error(
-            String(
-              ctx.__error ?? ctx.error ?? "actor_session_state persistence query failed"
-            )
-          );
-        }
-        const rowCount = Number(ctx.rowCount ?? 0);
-        if (!Number.isFinite(rowCount) || rowCount <= 0) {
-          throw new Error(
-            "actor_session_state persistence did not affect any rows (possible stale durable_version)"
-          );
-        }
-        return {
-          __success: true,
-          persisted: true,
-          actor_name: ctx.actor_name,
-          actor_version: ctx.actor_version,
-          actor_key: ctx.actor_key,
-          service_name: ctx.service_name,
-          durable_version: ctx.durable_version
-        };
-      },
-      "Enforces strict actor session persistence success contract.",
-      { isSubMeta: true, concurrency: 100 }
-    );
-    const insertAndValidateActorSessionStateTask = actorSessionStateInsertTask.then(
-      validateActorSessionStatePersistenceTask
-    );
-    CadenzaService.createMetaTask(
-      "Persist actor session state",
-      (ctx) => {
-        const actorName = typeof ctx.actor_name === "string" ? ctx.actor_name.trim() : "";
-        const actorKey = typeof ctx.actor_key === "string" ? ctx.actor_key.trim() : "";
-        const actorVersion = Number(ctx.actor_version ?? 1);
-        const durableVersion = Number(ctx.durable_version);
-        if (!actorName) {
-          throw new Error("actor_name is required for actor session persistence");
-        }
-        if (!actorKey) {
-          throw new Error("actor_key is required for actor session persistence");
-        }
-        if (!Number.isInteger(actorVersion) || actorVersion < 1) {
-          throw new Error("actor_version must be a positive integer");
-        }
-        if (!Number.isInteger(durableVersion) || durableVersion < 0) {
-          throw new Error("durable_version must be a non-negative integer");
-        }
-        if (typeof ctx.durable_state !== "object" || ctx.durable_state === null || Array.isArray(ctx.durable_state)) {
-          throw new Error("durable_state must be a non-null object");
-        }
-        const serviceName = CadenzaService.serviceRegistry.serviceName;
-        if (!serviceName) {
-          throw new Error("service_name is not available for actor session persistence");
-        }
-        let expiresAt = null;
-        if (ctx.expires_at !== void 0 && ctx.expires_at !== null) {
-          if (ctx.expires_at instanceof Date) {
-            expiresAt = ctx.expires_at.toISOString();
-          } else if (typeof ctx.expires_at === "string" && ctx.expires_at.trim().length > 0) {
-            expiresAt = ctx.expires_at;
-          } else {
-            throw new Error("expires_at must be null, Date, or non-empty string");
-          }
-        }
-        const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        return {
-          ...ctx,
-          actor_name: actorName,
-          actor_key: actorKey,
-          actor_version: actorVersion,
-          durable_version: durableVersion,
-          expires_at: expiresAt,
-          service_name: serviceName,
-          queryData: {
-            data: {
-              actor_name: actorName,
-              actor_version: actorVersion,
-              actor_key: actorKey,
-              service_name: serviceName,
-              durable_state: ctx.durable_state,
-              durable_version: durableVersion,
-              expires_at: expiresAt,
-              updated: updatedAt
-            },
-            onConflict: {
-              target: [
-                "actor_name",
-                "actor_version",
-                "actor_key",
-                "service_name"
-              ],
-              action: {
-                do: "update",
-                set: {
-                  durable_state: "excluded",
-                  durable_version: "excluded",
-                  expires_at: "excluded",
-                  updated: "excluded"
-                },
-                where: "actor_session_state.durable_version <= excluded.durable_version"
-              }
-            }
-          }
-        };
-      },
-      "Validates and prepares actor_session_state payload for strict write-through persistence.",
-      { isSubMeta: true, concurrency: 100 }
-    ).then(insertAndValidateActorSessionStateTask).respondsTo(META_ACTOR_SESSION_STATE_PERSIST_INTENT);
+    registerActorSessionPersistenceTasks();
     CadenzaService.createMetaTask("Handle Intent Creation", (ctx) => {
       const intentName = ctx.data?.name;
       return {
@@ -5195,6 +5658,9 @@ function normalizeIntentToken(value) {
   }
   return normalized;
 }
+function buildPostgresActorName(name) {
+  return `${String(name ?? "").trim()}PostgresActor`;
+}
 function validateIntentName(intentName) {
   if (!intentName || typeof intentName !== "string") {
     throw new Error("Intent name must be a non-empty string");
@@ -5332,7 +5798,8 @@ function resolveDataRows(data) {
 }
 var DatabaseController = class _DatabaseController {
   constructor() {
-    this.registrationsByService = /* @__PURE__ */ new Map();
+    this.registrationsByActorName = /* @__PURE__ */ new Map();
+    this.registrationsByActorToken = /* @__PURE__ */ new Map();
     this.adminDbClient = new Pool({
       connectionString: process.env.DATABASE_ADDRESS ?? "",
       database: "postgres",
@@ -5343,15 +5810,11 @@ var DatabaseController = class _DatabaseController {
     CadenzaService.createMetaTask(
       "Route PostgresActor setup requests",
       (ctx) => {
-        const serviceName = String(ctx.options?.serviceName ?? ctx.serviceName ?? "");
-        if (!serviceName) {
-          return ctx;
-        }
-        const registration = this.registrationsByService.get(serviceName);
+        const registration = this.resolveRegistration(ctx);
         if (!registration) {
           return ctx;
         }
-        CadenzaService.emit(`meta.postgres_actor.setup_requested.${registration.actorToken}`, ctx);
+        this.requestPostgresActorSetup(registration, ctx);
         return ctx;
       },
       "Routes generic database init requests to actor-scoped setup signal.",
@@ -5363,23 +5826,25 @@ var DatabaseController = class _DatabaseController {
     return this._instance;
   }
   reset() {
-    for (const registration of this.registrationsByService.values()) {
+    for (const registration of this.registrationsByActorName.values()) {
       const runtimeState = registration.actor.getRuntimeState(registration.actorKey);
       if (runtimeState?.pool) {
         runtimeState.pool.end().catch(() => void 0);
       }
     }
-    this.registrationsByService.clear();
+    this.registrationsByActorName.clear();
+    this.registrationsByActorToken.clear();
     this.adminDbClient.end().catch(() => void 0);
   }
-  createPostgresActor(serviceName, schema, options) {
-    const existing = this.registrationsByService.get(serviceName);
+  createPostgresActor(name, schema, description, options) {
+    const actorName = buildPostgresActorName(name);
+    const existing = this.registrationsByActorName.get(actorName);
     if (existing) {
       return existing;
     }
-    const actorName = `${serviceName}PostgresActor`;
     const actorToken = normalizeIntentToken(actorName);
-    const actorKey = String(options.databaseName ?? snakeCase(serviceName));
+    const actorKey = String(options.databaseName ?? snakeCase(name));
+    const ownerServiceName = options.ownerServiceName ?? CadenzaService.serviceRegistry?.serviceName ?? null;
     const optionTimeout = typeof options.timeoutMs === "number" ? Number(options.timeoutMs) : Number(options.timeout);
     const safetyPolicy = {
       statementTimeoutMs: normalizePositiveInteger(
@@ -5397,7 +5862,7 @@ var DatabaseController = class _DatabaseController {
     const actor = CadenzaService.createActor(
       {
         name: actorName,
-        description: "Specialized PostgresActor owning pool runtime state and schema-driven DB task generation.",
+        description: description || "Specialized PostgresActor owning pool runtime state and schema-driven DB task generation.",
         defaultKey: actorKey,
         keyResolver: (input) => typeof input.databaseName === "string" ? input.databaseName : void 0,
         loadPolicy: "eager",
@@ -5405,7 +5870,7 @@ var DatabaseController = class _DatabaseController {
         initState: {
           actorName,
           actorToken,
-          serviceName,
+          ownerServiceName,
           databaseName: actorKey,
           status: "idle",
           schemaVersion: Number(schema.version ?? 1),
@@ -5420,23 +5885,99 @@ var DatabaseController = class _DatabaseController {
       { isMeta: Boolean(options.isMeta) }
     );
     const registration = {
-      serviceName,
+      ownerServiceName,
       databaseName: actorKey,
       actorName,
       actorToken,
       actorKey,
+      setupSignal: `meta.postgres_actor.setup_requested.${actorToken}`,
+      setupDoneSignal: `meta.postgres_actor.setup_done.${actorToken}`,
+      setupFailedSignal: `meta.postgres_actor.setup_failed.${actorToken}`,
       actor,
       schema,
+      description,
       options,
       tasksGenerated: false,
       intentNames: /* @__PURE__ */ new Set()
     };
-    this.registrationsByService.set(serviceName, registration);
+    this.registrationsByActorName.set(actorName, registration);
+    this.registrationsByActorToken.set(actorToken, registration);
     this.registerSetupTask(registration);
     return registration;
   }
+  requestPostgresActorSetup(registrationOrName, ctx = {}) {
+    const registration = typeof registrationOrName === "string" ? this.resolveRegistration({
+      actorName: registrationOrName
+    }) : registrationOrName;
+    if (!registration) {
+      return void 0;
+    }
+    const payload = {
+      ...ctx,
+      actorName: registration.actorName,
+      actorToken: registration.actorToken,
+      databaseName: registration.databaseName,
+      ownerServiceName: registration.ownerServiceName,
+      options: {
+        ...ctx.options ?? {},
+        actorName: registration.actorName,
+        actorToken: registration.actorToken,
+        ownerServiceName: registration.ownerServiceName,
+        databaseName: registration.databaseName
+      }
+    };
+    const runtimeState = registration.actor.getRuntimeState(registration.actorKey);
+    if (runtimeState?.ready) {
+      this.emitSetupDone(registration, payload);
+      return registration;
+    }
+    CadenzaService.emit(registration.setupSignal, payload);
+    return registration;
+  }
+  resolveRegistration(ctx) {
+    const rawActorToken = String(
+      ctx.options?.actorToken ?? ctx.actorToken ?? ""
+    ).trim();
+    if (rawActorToken) {
+      const actorToken = normalizeIntentToken(rawActorToken);
+      const registration = this.registrationsByActorToken.get(actorToken);
+      if (registration) {
+        return registration;
+      }
+    }
+    const rawActorName = String(
+      ctx.options?.actorName ?? ctx.actorName ?? ctx.options?.postgresActorName ?? ctx.postgresActorName ?? ""
+    ).trim();
+    if (rawActorName) {
+      const registration = this.registrationsByActorName.get(rawActorName) ?? this.registrationsByActorName.get(buildPostgresActorName(rawActorName));
+      if (registration) {
+        return registration;
+      }
+    }
+    const legacyServiceName = String(
+      ctx.options?.serviceName ?? ctx.serviceName ?? ""
+    ).trim();
+    if (legacyServiceName) {
+      return this.registrationsByActorName.get(
+        buildPostgresActorName(legacyServiceName)
+      );
+    }
+    return void 0;
+  }
+  emitSetupDone(registration, payload) {
+    const resolvedPayload = {
+      ...payload,
+      actorName: registration.actorName,
+      actorToken: registration.actorToken,
+      databaseName: registration.databaseName,
+      ownerServiceName: registration.ownerServiceName,
+      __success: true
+    };
+    CadenzaService.emit(registration.setupDoneSignal, resolvedPayload);
+    CadenzaService.emit("meta.postgres_actor.setup_done", resolvedPayload);
+    CadenzaService.emit("meta.database.setup_done", resolvedPayload);
+  }
   registerSetupTask(registration) {
-    const setupSignal = `meta.postgres_actor.setup_requested.${registration.actorToken}`;
     CadenzaService.createMetaTask(
       `Setup ${registration.actorName}`,
       registration.actor.task(
@@ -5496,17 +6037,15 @@ var DatabaseController = class _DatabaseController {
               lastError: null,
               tables: Object.keys(registration.schema.tables ?? {})
             });
-            emit("meta.database.setup_done", {
-              serviceName: registration.serviceName,
-              databaseName: registration.databaseName,
-              actorName: registration.actorName,
-              __success: true
+            this.emitSetupDone(registration, {
+              ...input
             });
             return {
               ...input,
               __success: true,
               actorName: registration.actorName,
-              databaseName: registration.databaseName
+              databaseName: registration.databaseName,
+              ownerServiceName: registration.ownerServiceName
             };
           } catch (error) {
             const message = errorMessage(error);
@@ -5530,7 +6069,11 @@ var DatabaseController = class _DatabaseController {
       ),
       "Initializes PostgresActor runtime pool, applies schema, and generates CRUD tasks/intents.",
       { isMeta: true }
-    ).doOn(setupSignal);
+    ).doOn(registration.setupSignal).emitsOnFail(
+      registration.setupFailedSignal,
+      "meta.postgres_actor.setup_failed",
+      "meta.database.setup_failed"
+    );
   }
   createTargetPool(databaseName, statementTimeoutMs) {
     const connectionString = this.buildDatabaseConnectionString(databaseName);
@@ -7706,6 +8249,165 @@ var GraphSyncController = class _GraphSyncController {
   }
 };
 
+// src/utils/bootstrap.ts
+var DEFAULT_BOOTSTRAP_GLOBAL_KEY = "__CADENZA_RUNTIME__";
+function normalizeString3(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function readEnvString(name) {
+  if (typeof process === "undefined") {
+    return void 0;
+  }
+  return normalizeString3(process.env?.[name]);
+}
+function readConfiguredPort(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Invalid port value: ${String(value)}`);
+  }
+  const normalized = Math.trunc(parsed);
+  if (normalized <= 0) {
+    throw new Error(`Port must be a positive integer: ${String(value)}`);
+  }
+  return normalized;
+}
+function buildBootstrapUrl(protocol, address, port) {
+  return `${protocol}://${address}:${port}`;
+}
+function resolveInjectedBootstrapUrl(injectedGlobalKey) {
+  if (typeof globalThis === "undefined") {
+    return void 0;
+  }
+  const runtimeConfig = globalThis[injectedGlobalKey];
+  return normalizeString3(runtimeConfig?.bootstrapUrl);
+}
+function resolveExplicitBootstrapValue(options) {
+  const injectedGlobalKey = normalizeString3(options.bootstrap?.injectedGlobalKey) ?? DEFAULT_BOOTSTRAP_GLOBAL_KEY;
+  const explicitBootstrapUrl = normalizeString3(options.bootstrap?.url);
+  if (explicitBootstrapUrl) {
+    return {
+      value: explicitBootstrapUrl,
+      port: readConfiguredPort(options.cadenzaDB?.port),
+      injectedGlobalKey
+    };
+  }
+  if (options.runtime === "browser") {
+    const injected = resolveInjectedBootstrapUrl(injectedGlobalKey);
+    if (injected) {
+      return {
+        value: injected,
+        port: readConfiguredPort(options.cadenzaDB?.port),
+        injectedGlobalKey
+      };
+    }
+  }
+  const explicitAddress = normalizeString3(options.cadenzaDB?.address);
+  if (explicitAddress) {
+    return {
+      value: explicitAddress,
+      port: readConfiguredPort(options.cadenzaDB?.port),
+      injectedGlobalKey
+    };
+  }
+  const envAddress = readEnvString("CADENZA_DB_ADDRESS");
+  return {
+    value: envAddress,
+    port: readConfiguredPort(options.cadenzaDB?.port ?? readEnvString("CADENZA_DB_PORT")),
+    injectedGlobalKey
+  };
+}
+function readIntegerEnv(name, fallback) {
+  const raw = readEnvString(name);
+  if (!raw) {
+    return fallback;
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    return fallback;
+  }
+  const normalized = Math.trunc(parsed);
+  if (normalized <= 0) {
+    return fallback;
+  }
+  return normalized;
+}
+function readStringEnv(name) {
+  return readEnvString(name);
+}
+function readListEnv(name) {
+  const raw = readEnvString(name);
+  if (!raw) {
+    return [];
+  }
+  return raw.split("|").map((entry) => entry.trim()).filter((entry) => entry.length > 0).map((entry) => entry.split(",").map((part) => part.trim()));
+}
+function resolveBootstrapEndpoint(options) {
+  const { value, port: fallbackPort, injectedGlobalKey } = resolveExplicitBootstrapValue(options);
+  if (!value) {
+    throw new Error(
+      options.runtime === "browser" ? `No bootstrap URL available. Pass bootstrap.url or inject globalThis.${injectedGlobalKey}.bootstrapUrl.` : "No bootstrap URL available. Set CADENZA_DB_ADDRESS or pass bootstrap.url."
+    );
+  }
+  const raw = value.trim();
+  if (raw.length === 0) {
+    throw new Error("Bootstrap URL cannot be empty");
+  }
+  if (raw.includes("://")) {
+    const parsed2 = new URL(raw);
+    const protocol2 = parsed2.protocol.replace(":", "");
+    if (protocol2 !== "http" && protocol2 !== "https") {
+      throw new Error(`Unsupported bootstrap protocol: ${parsed2.protocol}`);
+    }
+    if (parsed2.pathname && parsed2.pathname !== "/" && parsed2.pathname.trim().length > 0) {
+      throw new Error(
+        "Bootstrap URL must be an origin without a path component."
+      );
+    }
+    const port2 = parsed2.port ? readConfiguredPort(parsed2.port) : fallbackPort;
+    if (!port2) {
+      throw new Error(
+        "Bootstrap URL must include a port or CADENZA_DB_PORT must be provided."
+      );
+    }
+    return {
+      url: buildBootstrapUrl(protocol2, parsed2.hostname, port2),
+      protocol: protocol2,
+      address: parsed2.hostname,
+      port: port2,
+      exposed: protocol2 === "https",
+      injectedGlobalKey
+    };
+  }
+  if (raw.includes("/") || raw.includes("?") || raw.includes("#")) {
+    throw new Error(
+      "Bootstrap address without protocol must not include a path, query, or hash."
+    );
+  }
+  const parsed = new URL(`http://${raw}`);
+  const protocol = "http";
+  const port = parsed.port ? readConfiguredPort(parsed.port) : fallbackPort;
+  if (!port) {
+    throw new Error(
+      "Bootstrap address must include a port or CADENZA_DB_PORT must be provided."
+    );
+  }
+  return {
+    url: buildBootstrapUrl(protocol, parsed.hostname, port),
+    protocol,
+    address: parsed.hostname,
+    port,
+    exposed: false,
+    injectedGlobalKey
+  };
+}
+
 // src/Cadenza.ts
 var CadenzaService = class {
   /**
@@ -7724,11 +8426,60 @@ var CadenzaService = class {
     this.metaRunner = Cadenza.metaRunner;
     this.registry = Cadenza.registry;
     this.serviceRegistry = ServiceRegistry.instance;
-    SignalController.instance;
     RestController.instance;
     SocketController.instance;
     console.log("BOOTSTRAPPED");
   }
+  static ensureTransportControllers(isFrontend) {
+    if (!isFrontend) {
+      SignalController.instance;
+    }
+  }
+  static setHydrationResults(hydration) {
+    this.hydratedInquiryResults = /* @__PURE__ */ new Map();
+    const initialInquiryResults = hydration?.initialInquiryResults ?? {};
+    for (const [key, value] of Object.entries(initialInquiryResults)) {
+      this.hydratedInquiryResults.set(key, value);
+    }
+  }
+  static consumeHydratedInquiryResult(hydrationKey) {
+    if (!hydrationKey) {
+      return void 0;
+    }
+    const result = this.hydratedInquiryResults.get(hydrationKey);
+    if (result === void 0) {
+      return void 0;
+    }
+    this.hydratedInquiryResults.delete(hydrationKey);
+    return result;
+  }
+  static ensureFrontendSyncLoop() {
+    if (this.frontendSyncScheduled) {
+      return;
+    }
+    this.frontendSyncScheduled = true;
+    Cadenza.interval("meta.sync_requested", { __syncing: false }, 18e4);
+    Cadenza.schedule("meta.sync_requested", { __syncing: false }, 250);
+  }
+  static normalizeDeclaredTransports(transports, serviceId) {
+    return (transports ?? []).map((transport) => normalizeServiceTransportConfig(transport)).filter(
+      (transport) => !!transport
+    ).map((transport, index) => ({
+      ...transport,
+      uuid: `${serviceId}-transport-${index + 1}`
+    }));
+  }
+  static createBootstrapTransport(serviceInstanceId, role, endpoint) {
+    return {
+      uuid: `${serviceInstanceId}-${role}-bootstrap`,
+      service_instance_id: serviceInstanceId,
+      role,
+      origin: endpoint.url,
+      protocols: ["rest", "socket"],
+      security_profile: null,
+      auth_strategy: null
+    };
+  }
   /**
    * Validates the provided service name based on specific rules.
    *
@@ -7841,6 +8592,12 @@ var CadenzaService = class {
   }
   static async inquire(inquiry, context, options = {}) {
     this.bootstrap();
+    const hydratedResult = this.consumeHydratedInquiryResult(
+      options.hydrationKey
+    );
+    if (hydratedResult !== void 0) {
+      return hydratedResult;
+    }
     const observer = this.inquiryBroker?.inquiryObservers.get(inquiry);
     const allResponders = observer ? Array.from(observer.tasks).map((task) => ({
       task,
@@ -8445,58 +9202,97 @@ var CadenzaService = class {
     const serviceId = options.customServiceId ?? uuid3();
     this.serviceRegistry.serviceName = serviceName;
     this.serviceRegistry.serviceInstanceId = serviceId;
+    this.setHydrationResults(options.hydration);
+    const explicitFrontendMode = options.isFrontend;
     options = {
       loadBalance: true,
       useSocket: true,
       displayName: void 0,
       isMeta: false,
-      port: parseInt(process.env.HTTP_PORT ?? "3000"),
-      securityProfile: process.env.SECURITY_PROFILE ?? "medium",
-      networkMode: process.env.NETWORK_MODE ?? "dev",
+      port: readIntegerEnv("HTTP_PORT", 3e3),
+      securityProfile: readStringEnv("SECURITY_PROFILE") ?? "medium",
+      networkMode: readStringEnv("NETWORK_MODE") ?? "dev",
       retryCount: 3,
       cadenzaDB: {
-        connect: true,
-        address: process.env.CADENZA_DB_ADDRESS ?? "localhost",
-        port: parseInt(process.env.CADENZA_DB_PORT ?? "5000")
+        connect: true
       },
-      relatedServices: process.env.RELATED_SERVICES ? process.env.RELATED_SERVICES.split("|").map(
-        (s) => s.trim().split(",")
-      ) : [],
-      isFrontend: isBrowser,
+      relatedServices: readListEnv("RELATED_SERVICES"),
+      isFrontend: typeof explicitFrontendMode === "boolean" ? explicitFrontendMode : isBrowser,
       ...options
     };
+    const isFrontend = !!options.isFrontend;
+    const declaredTransports = this.normalizeDeclaredTransports(
+      options.transports,
+      serviceId
+    );
+    this.serviceRegistry.isFrontend = isFrontend;
+    this.serviceRegistry.useSocket = !!options.useSocket;
+    this.serviceRegistry.retryCount = options.retryCount ?? 3;
+    this.ensureTransportControllers(isFrontend);
+    const resolvedBootstrapEndpoint = options.cadenzaDB?.connect ? resolveBootstrapEndpoint({
+      runtime: isFrontend ? "browser" : "server",
+      bootstrap: options.bootstrap,
+      cadenzaDB: options.cadenzaDB
+    }) : void 0;
+    if (resolvedBootstrapEndpoint) {
+      options.cadenzaDB = {
+        ...options.cadenzaDB,
+        connect: true,
+        address: resolvedBootstrapEndpoint.address,
+        port: resolvedBootstrapEndpoint.port
+      };
+    }
     if (options.cadenzaDB?.connect) {
       this.emit("meta.initializing_service", {
         // Seed the CadenzaDB
         serviceInstance: {
           uuid: "cadenza-db",
           serviceName: "CadenzaDB",
-          address: options.cadenzaDB?.address,
-          port: options.cadenzaDB?.port,
-          exposed: options.networkMode !== "dev",
           numberOfRunningGraphs: 0,
           isActive: true,
           // Assume it is deployed
           isNonResponsive: false,
           isBlocked: false,
-          health: {}
+          health: {},
+          isFrontend: false,
+          transports: resolvedBootstrapEndpoint ? [
+            this.createBootstrapTransport(
+              "cadenza-db",
+              isFrontend ? "public" : "internal",
+              resolvedBootstrapEndpoint
+            )
+          ] : []
         }
       });
     }
     options.relatedServices?.forEach((service) => {
+      const relatedTransport = normalizeServiceTransportConfig({
+        role: isFrontend ? "public" : "internal",
+        origin: service[2].includes("://") ? service[2] : `http://${service[2]}`,
+        protocols: ["rest", "socket"]
+      });
       this.emit("meta.initializing_service", {
         serviceInstance: {
           uuid: service[0],
           serviceName: service[1],
-          address: service[2].split(":")[0],
-          port: service[2].split(":")[1] ?? 3e3,
-          exposed: options.networkMode !== "dev",
           numberOfRunningGraphs: 0,
           isActive: true,
           // Assume it is deployed
           isNonResponsive: false,
           isBlocked: false,
-          health: {}
+          health: {},
+          isFrontend: false,
+          transports: relatedTransport ? [
+            {
+              uuid: `${service[0]}-${relatedTransport.role}`,
+              service_instance_id: service[0],
+              role: relatedTransport.role,
+              origin: relatedTransport.origin,
+              protocols: relatedTransport.protocols ?? ["rest", "socket"],
+              security_profile: relatedTransport.securityProfile ?? null,
+              auth_strategy: relatedTransport.authStrategy ?? null
+            }
+          ] : []
         }
       });
     });
@@ -8517,7 +9313,9 @@ var CadenzaService = class {
       __networkMode: options.networkMode,
       __retryCount: options.retryCount,
       __cadenzaDBConnect: options.cadenzaDB?.connect,
-      __isDatabase: options.isDatabase
+      __isDatabase: options.isDatabase,
+      __isFrontend: isFrontend,
+      __declaredTransports: declaredTransports
     };
     if (options.cadenzaDB?.connect) {
       this.createEphemeralMetaTask("Create service", async (context, emit) => {
@@ -8533,12 +9331,42 @@ var CadenzaService = class {
       }).doOn("meta.rest.handshake");
     }
     this.createMetaTask("Handle service setup completion", () => {
-      GraphMetadataController.instance;
-      GraphSyncController.instance.isCadenzaDBReady = !!options.cadenzaDB?.connect;
-      GraphSyncController.instance.init();
+      if (isFrontend) {
+        registerActorSessionPersistenceTasks();
+        this.ensureFrontendSyncLoop();
+      } else {
+        GraphMetadataController.instance;
+        GraphSyncController.instance.isCadenzaDBReady = !!options.cadenzaDB?.connect;
+        GraphSyncController.instance.init();
+      }
       this.log("Service created.");
       return true;
     }).doOn("meta.service_registry.instance_inserted");
+    if (!options.cadenzaDB?.connect && isFrontend) {
+      Cadenza.schedule(
+        "meta.service_registry.instance_registration_requested",
+        {
+          data: {
+            uuid: serviceId,
+            process_pid: 1,
+            service_name: serviceName,
+            is_frontend: true,
+            is_active: true,
+            is_non_responsive: false,
+            is_blocked: false,
+            health: {}
+          },
+          transportData: [],
+          __serviceName: serviceName,
+          __serviceInstanceId: serviceId,
+          __useSocket: options.useSocket,
+          __retryCount: options.retryCount,
+          __isFrontend: true,
+          __skipRemoteExecution: true
+        },
+        0
+      );
+    }
     this.serviceCreated = true;
   }
   /**
@@ -8554,87 +9382,52 @@ var CadenzaService = class {
     this.createCadenzaService(serviceName, description, options);
   }
   /**
-   * Creates and initializes a PostgresActor-backed database service.
-   * This is the canonical API for schema-driven postgres setup in cadenza-service.
+   * Creates and initializes a specialized PostgresActor.
+   * This is actor-only and does not create or register a network service.
    *
-   * @param {string} name - Logical actor/service name.
+   * @param {string} name - Logical PostgresActor name.
    * @param {DatabaseSchemaDefinition} schema - Database schema definition.
-   * @param {string} [description=""] - Optional human-readable description.
-   * @param {ServerOptions & DatabaseOptions} [options={}] - Server/database runtime options.
+   * @param {string} [description=""] - Optional human-readable actor description.
+   * @param {ServerOptions & DatabaseOptions} [options={}] - Actor/database runtime options.
    * @return {void}
    */
   static createPostgresActor(name, schema, description = "", options = {}) {
-    if (isBrowser) {
+    if (isBrowser || options.isFrontend) {
       console.warn(
-        "Database service creation is not supported in the browser. Use the CadenzaDB service instead."
+        "PostgresActor creation is not supported in frontend mode."
       );
       return;
     }
-    if (this.serviceCreated) return;
     this.bootstrap();
-    this.serviceRegistry.serviceName = name;
+    this.validateName(name);
     const databaseController = DatabaseController.instance;
-    options = {
-      loadBalance: true,
-      useSocket: true,
-      displayName: void 0,
-      isMeta: false,
-      port: parseInt(process.env.HTTP_PORT ?? "3000"),
-      securityProfile: process.env.SECURITY_PROFILE ?? "medium",
-      networkMode: process.env.NETWORK_MODE ?? "dev",
-      retryCount: 3,
-      cadenzaDB: {
-        connect: true,
-        address: process.env.CADENZA_DB_ADDRESS ?? "localhost",
-        port: parseInt(process.env.CADENZA_DB_PORT ?? "5000")
-      },
-      databaseType: "postgres",
-      databaseName: snakeCase2(name),
-      poolSize: parseInt(process.env.DATABASE_POOL_SIZE ?? "10"),
-      isDatabase: true,
-      ...options
-    };
+    const normalizedOptions = this.normalizePostgresActorOptions(name, options);
     const registration = databaseController.createPostgresActor(
       name,
       schema,
-      options
+      description,
+      normalizedOptions
     );
     console.log("Creating PostgresActor", {
-      serviceName: name,
+      name,
       actorName: registration.actorName,
-      options
+      ownerServiceName: normalizedOptions.ownerServiceName ?? null,
+      options: normalizedOptions
     });
-    this.emit("meta.database_init_requested", {
-      schema,
-      databaseName: options.databaseName,
-      options
+    databaseController.requestPostgresActorSetup(registration, {
+      actorName: registration.actorName,
+      actorToken: registration.actorToken,
+      databaseName: normalizedOptions.databaseName,
+      ownerServiceName: normalizedOptions.ownerServiceName ?? null
     });
-    this.createMetaTask("Set database connection", () => {
-      this.createMetaTask("Insert database service bridge", (_, emit) => {
-        emit("global.meta.created_database_service", {
-          data: {
-            service_name: name,
-            description,
-            schema,
-            is_meta: options.isMeta
-          }
-        });
-        this.log("Database service created", {
-          name,
-          isMeta: options.isMeta,
-          actorName: registration.actorName
-        });
-      }).doOn("meta.service_registry.service_inserted");
-      this.createCadenzaService(name, description, options);
-    }).doOn("meta.database.setup_done");
   }
   /**
-   * Creates a meta PostgresActor service.
+   * Creates a meta PostgresActor.
    *
-   * @param {string} name - Logical actor/service name.
+   * @param {string} name - Logical PostgresActor name.
    * @param {DatabaseSchemaDefinition} schema - Database schema definition.
    * @param {string} [description=""] - Optional description.
-   * @param {ServerOptions & DatabaseOptions} [options={}] - Optional server/database options.
+   * @param {ServerOptions & DatabaseOptions} [options={}] - Optional actor/database options.
    * @return {void}
    */
   static createMetaPostgresActor(name, schema, description = "", options = {}) {
@@ -8643,10 +9436,84 @@ var CadenzaService = class {
     this.createPostgresActor(name, schema, description, options);
   }
   /**
-   * Legacy compatibility wrapper. Prefer {@link createPostgresActor}.
+   * Creates a dedicated database service by composing a PostgresActor and a Cadenza service.
    */
   static createDatabaseService(name, schema, description = "", options = {}) {
-    this.createPostgresActor(name, schema, description, options);
+    if (isBrowser || options.isFrontend) {
+      console.warn(
+        "Database service creation is not supported in frontend mode. Use the CadenzaDB service instead."
+      );
+      return;
+    }
+    if (this.serviceCreated) return;
+    this.bootstrap();
+    this.validateName(name);
+    this.validateServiceName(name);
+    const databaseController = DatabaseController.instance;
+    const actorOptions = this.normalizePostgresActorOptions(name, {
+      ...options,
+      ownerServiceName: options.ownerServiceName ?? name
+    });
+    const serviceOptions = this.normalizeDatabaseServiceOptions(name, {
+      ...options,
+      ownerServiceName: actorOptions.ownerServiceName
+    });
+    const registration = databaseController.createPostgresActor(
+      name,
+      schema,
+      description,
+      actorOptions
+    );
+    this.registerDatabaseServiceBridgeTask(
+      name,
+      description,
+      schema,
+      Boolean(serviceOptions.isMeta),
+      registration.actorName
+    );
+    const createServiceTaskName = `Create database service ${name} after ${registration.actorName} setup`;
+    if (!this.get(createServiceTaskName)) {
+      this.createMetaTask(
+        createServiceTaskName,
+        () => {
+          this.createCadenzaService(name, description, serviceOptions);
+          return true;
+        },
+        "Creates the networked database service after PostgresActor setup completes."
+      ).doOn(registration.setupDoneSignal);
+    }
+    const setupFailureTaskName = `Handle database service ${name} bootstrap failure`;
+    if (!this.get(setupFailureTaskName)) {
+      this.createMetaTask(
+        setupFailureTaskName,
+        (ctx) => {
+          this.log(
+            "Database service bootstrap failed before service creation.",
+            {
+              serviceName: name,
+              actorName: registration.actorName,
+              databaseName: registration.databaseName,
+              error: ctx.__error
+            },
+            "error"
+          );
+          return true;
+        },
+        "Logs PostgresActor setup failures for database service bootstrap."
+      ).doOn(registration.setupFailedSignal);
+    }
+    console.log("Creating database service wrapper", {
+      serviceName: name,
+      actorName: registration.actorName,
+      actorOptions,
+      serviceOptions
+    });
+    databaseController.requestPostgresActorSetup(registration, {
+      actorName: registration.actorName,
+      actorToken: registration.actorToken,
+      databaseName: actorOptions.databaseName,
+      ownerServiceName: actorOptions.ownerServiceName ?? name
+    });
   }
   /**
    * Creates a meta database service with the specified configuration.
@@ -8658,7 +9525,71 @@ var CadenzaService = class {
    * @return {void} - This method does not return a value.
    */
   static createMetaDatabaseService(name, schema, description = "", options = {}) {
-    this.createMetaPostgresActor(name, schema, description, options);
+    this.createDatabaseService(name, schema, description, {
+      ...options,
+      isMeta: true
+    });
+  }
+  static normalizePostgresActorOptions(name, options = {}) {
+    return {
+      isMeta: false,
+      retryCount: 3,
+      databaseType: "postgres",
+      databaseName: snakeCase2(name),
+      poolSize: readIntegerEnv("DATABASE_POOL_SIZE", 10),
+      ownerServiceName: options.ownerServiceName ?? this.serviceRegistry?.serviceName ?? null,
+      ...options
+    };
+  }
+  static normalizeDatabaseServiceOptions(name, options = {}) {
+    return {
+      loadBalance: true,
+      useSocket: true,
+      displayName: void 0,
+      isMeta: false,
+      port: readIntegerEnv("HTTP_PORT", 3e3),
+      securityProfile: readStringEnv("SECURITY_PROFILE") ?? "medium",
+      networkMode: readStringEnv("NETWORK_MODE") ?? "dev",
+      retryCount: 3,
+      cadenzaDB: {
+        connect: true
+      },
+      databaseType: "postgres",
+      databaseName: snakeCase2(name),
+      poolSize: readIntegerEnv("DATABASE_POOL_SIZE", 10),
+      isDatabase: true,
+      ownerServiceName: options.ownerServiceName ?? name,
+      ...options
+    };
+  }
+  static registerDatabaseServiceBridgeTask(serviceName, description, schema, isMeta, actorName) {
+    const taskName = `Insert database service bridge ${serviceName}`;
+    if (this.get(taskName)) {
+      return;
+    }
+    this.createMetaTask(
+      taskName,
+      (ctx, emit) => {
+        if (ctx.__serviceName && ctx.__serviceName !== serviceName) {
+          return false;
+        }
+        emit("global.meta.created_database_service", {
+          data: {
+            service_name: serviceName,
+            description,
+            schema,
+            is_meta: isMeta
+          }
+        });
+        this.log("Database service created", {
+          name: serviceName,
+          isMeta,
+          actorName
+        });
+        return true;
+      },
+      "Bridges database service creation into the global metadata signal."
+    ).doOn("meta.service_registry.service_inserted");
   }
   static createActor(spec, options = {}) {
     this.bootstrap();
@@ -9011,14 +9942,14 @@ var CadenzaService = class {
     return Cadenza.createEphemeralTask(name, func, description, options);
   }
   /**
-   * Creates an ephemeral meta task with the specified name, function, description, and options.
+   * Creates an ephemeral meta-task with the specified name, function, description, and options.
    * See {@link createEphemeralTask} and {@link createMetaTask} for more details.
    *
    * @param {string} name - The name of the task to be created.
    * @param {TaskFunction} func - The function to be executed as part of the task.
    * @param {string} [description] - An optional description of the task.
    * @param {TaskOptions & EphemeralTaskOptions} [options={}] - Additional options for configuring the task.
-   * @return {EphemeralTask} The created ephemeral meta task.
+   * @return {EphemeralTask} The created ephemeral meta-task.
    */
   static createEphemeralMetaTask(name, func, description, options = {}) {
     this.bootstrap();
@@ -9073,12 +10004,19 @@ var CadenzaService = class {
   }
   static reset() {
     Cadenza.reset();
-    this.serviceRegistry.reset();
+    this.serviceRegistry?.reset();
+    this.isBootstrapped = false;
+    this.serviceCreated = false;
+    this.warnedInvalidMetaIntentResponderKeys = /* @__PURE__ */ new Set();
+    this.hydratedInquiryResults = /* @__PURE__ */ new Map();
+    this.frontendSyncScheduled = false;
   }
 };
 CadenzaService.isBootstrapped = false;
 CadenzaService.serviceCreated = false;
 CadenzaService.warnedInvalidMetaIntentResponderKeys = /* @__PURE__ */ new Set();
+CadenzaService.hydratedInquiryResults = /* @__PURE__ */ new Map();
+CadenzaService.frontendSyncScheduled = false;
 
 // src/index.ts
 import {
@@ -9088,9 +10026,274 @@ import {
   GraphRoutine as GraphRoutine2,
   Task as Task4
 } from "@cadenza.io/core";
+
+// src/ssr/createSSRInquiryBridge.ts
+import { v4 as uuid4 } from "uuid";
+function ensureFetch() {
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error("SSR inquiry bridge requires global fetch support.");
+  }
+  return globalThis.fetch.bind(globalThis);
+}
+function normalizeArrayResponse(value, keys) {
+  for (const key of keys) {
+    if (Array.isArray(value?.[key])) {
+      return value[key];
+    }
+  }
+  if (Array.isArray(value?.rows)) {
+    return value.rows;
+  }
+  if (Array.isArray(value?.data)) {
+    return value.data;
+  }
+  return [];
+}
+function normalizeIntentMap(raw) {
+  const intentName = String(raw.intentName ?? raw.intent_name ?? "").trim();
+  const serviceName = String(raw.serviceName ?? raw.service_name ?? "").trim();
+  const taskName = String(raw.taskName ?? raw.task_name ?? "").trim();
+  const taskVersion = Math.max(
+    1,
+    Math.trunc(Number(raw.taskVersion ?? raw.task_version ?? 1) || 1)
+  );
+  if (!intentName || !serviceName || !taskName) {
+    return null;
+  }
+  return {
+    intentName,
+    serviceName,
+    taskName,
+    taskVersion,
+    deleted: Boolean(raw.deleted)
+  };
+}
+function buildInquiryMeta(inquiry, startedAt, statuses) {
+  const counts = summarizeResponderStatuses(statuses);
+  return {
+    inquiry,
+    isMetaInquiry: isMetaIntentName(inquiry),
+    totalResponders: statuses.length,
+    eligibleResponders: statuses.length,
+    filteredOutResponders: 0,
+    responded: counts.responded,
+    failed: counts.failed,
+    timedOut: counts.timedOut,
+    pending: counts.pending,
+    durationMs: Date.now() - startedAt,
+    responders: statuses
+  };
+}
+function createSSRInquiryBridge(options = {}) {
+  const bootstrapEndpoint = resolveBootstrapEndpoint({
+    runtime: "server",
+    bootstrap: options.bootstrap,
+    cadenzaDB: options.cadenzaDB
+  });
+  const fetchImplementation = ensureFetch();
+  const initialInquiryResults = {};
+  const postDelegation = async (targetUrl, remoteRoutineName, context, timeoutMs) => {
+    const signal = AbortSignal.timeout(timeoutMs);
+    const response = await fetchImplementation(`${targetUrl}/delegation`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        ...context,
+        __remoteRoutineName: remoteRoutineName,
+        __metadata: {
+          ...context.__metadata ?? {},
+          __deputyExecId: uuid4()
+        }
+      }),
+      signal
+    });
+    return await response.json();
+  };
+  const queryTable = async (tableName, queryData, timeoutMs) => {
+    const response = await postDelegation(
+      bootstrapEndpoint.url,
+      `Query ${tableName}`,
+      { queryData },
+      timeoutMs
+    );
+    return normalizeArrayResponse(response, [
+      `${tableName}Rows`,
+      `${tableName}s`,
+      tableName,
+      tableName.replace(/_([a-z])/g, (_match, char) => char.toUpperCase())
+    ]);
+  };
+  return {
+    async inquire(inquiry, context = {}, inquiryOptions = {}) {
+      const startedAt = Date.now();
+      const overallTimeoutMs = inquiryOptions.overallTimeoutMs ?? inquiryOptions.timeout ?? 3e4;
+      const perResponderTimeoutMs = inquiryOptions.perResponderTimeoutMs ?? overallTimeoutMs;
+      const intentMaps = (await queryTable(
+        "intent_to_task_map",
+        {
+          filter: {
+            intent_name: inquiry
+          }
+        },
+        overallTimeoutMs
+      )).map(normalizeIntentMap).filter(
+        (item) => !!item && item.intentName === inquiry && !item.deleted
+      );
+      if (intentMaps.length === 0) {
+        return {
+          __inquiryMeta: buildInquiryMeta(inquiry, startedAt, [])
+        };
+      }
+      const relevantServiceNames = Array.from(
+        new Set(intentMaps.map((item) => item.serviceName))
+      );
+      const rawServiceInstances = await queryTable(
+        "service_instance",
+        {
+          filter: {
+            service_name: relevantServiceNames
+          }
+        },
+        overallTimeoutMs
+      );
+      const rawServiceTransports = await queryTable(
+        "service_instance_transport",
+        {
+          filter: {
+            deleted: false
+          }
+        },
+        overallTimeoutMs
+      );
+      const transportsByInstance = /* @__PURE__ */ new Map();
+      for (const transport of rawServiceTransports) {
+        const serviceInstanceId = String(
+          transport.serviceInstanceId ?? transport.service_instance_id ?? ""
+        ).trim();
+        if (!serviceInstanceId) {
+          continue;
+        }
+        if (!transportsByInstance.has(serviceInstanceId)) {
+          transportsByInstance.set(serviceInstanceId, []);
+        }
+        transportsByInstance.get(serviceInstanceId).push(transport);
+      }
+      const serviceInstances = rawServiceInstances.map(
+        (instance) => normalizeServiceInstanceDescriptor({
+          ...instance,
+          transports: transportsByInstance.get(String(instance.uuid ?? "").trim()) ?? []
+        })
+      ).filter(
+        (item) => !!item && relevantServiceNames.includes(item.serviceName) && item.isActive && !item.isNonResponsive && !item.isBlocked
+      ).sort((left, right) => {
+        if (left.serviceName !== right.serviceName) {
+          return left.serviceName.localeCompare(right.serviceName);
+        }
+        if (left.isPrimary !== right.isPrimary) {
+          return left.isPrimary ? -1 : 1;
+        }
+        return (left.numberOfRunningGraphs ?? 0) - (right.numberOfRunningGraphs ?? 0);
+      });
+      const statuses = intentMaps.map((map) => ({
+        isRemote: true,
+        serviceName: map.serviceName,
+        taskName: map.taskName,
+        taskVersion: map.taskVersion,
+        localTaskName: `SSR inquiry via ${map.serviceName} (${map.taskName} v${map.taskVersion})`,
+        status: "timed_out",
+        durationMs: 0
+      }));
+      const fulfilledContexts = await Promise.all(
+        intentMaps.map(async (map, index) => {
+          const status = statuses[index];
+          const startedAtForResponder = Date.now();
+          const selectedInstance = serviceInstances.find(
+            (instance) => instance.serviceName === map.serviceName
+          );
+          if (!selectedInstance) {
+            status.status = "failed";
+            status.error = `No active instances for ${map.serviceName}`;
+            status.durationMs = Date.now() - startedAtForResponder;
+            return null;
+          }
+          const targetTransport = selectTransportForRole(
+            selectedInstance.transports,
+            "internal",
+            "rest"
+          );
+          if (!targetTransport) {
+            status.status = "failed";
+            status.error = `No internal transport for ${selectedInstance.serviceName}/${selectedInstance.uuid}`;
+            status.durationMs = Date.now() - startedAtForResponder;
+            return null;
+          }
+          const targetUrl = targetTransport.origin;
+          try {
+            const result = await postDelegation(
+              targetUrl,
+              map.taskName,
+              context,
+              perResponderTimeoutMs
+            );
+            status.durationMs = Date.now() - startedAtForResponder;
+            if (result?.errored || result?.failed) {
+              status.status = "failed";
+              status.error = String(
+                result?.__error ?? result?.error ?? "Remote inquiry failed"
+              );
+              return null;
+            }
+            status.status = "fulfilled";
+            return result;
+          } catch (error) {
+            status.durationMs = Date.now() - startedAtForResponder;
+            if (error instanceof Error && (error.name === "AbortError" || /timed out/i.test(error.message))) {
+              status.status = "timed_out";
+              status.error = error.message;
+              return null;
+            }
+            status.status = "failed";
+            status.error = error instanceof Error ? error.message : String(error);
+            return null;
+          }
+        })
+      );
+      const mergedContext = mergeInquiryContexts(
+        fulfilledContexts.filter(
+          (item) => item !== null
+        )
+      );
+      const responseContext = {
+        ...mergedContext,
+        __inquiryMeta: buildInquiryMeta(inquiry, startedAt, statuses)
+      };
+      if (inquiryOptions.hydrationKey) {
+        initialInquiryResults[inquiryOptions.hydrationKey] = responseContext;
+      }
+      if (inquiryOptions.requireComplete && statuses.some((status) => status.status !== "fulfilled")) {
+        throw {
+          ...responseContext,
+          __error: `Inquiry '${inquiry}' did not complete successfully`,
+          errored: true
+        };
+      }
+      return responseContext;
+    },
+    dehydrate() {
+      return {
+        initialInquiryResults: { ...initialInquiryResults }
+      };
+    }
+  };
+}
+
+// src/index.ts
 var index_default = CadenzaService;
 export {
   Actor2 as Actor,
+  DatabaseController,
   DatabaseTask,
   DebounceTask2 as DebounceTask,
   DeputyTask,
@@ -9103,6 +10306,7 @@ export {
   SignalTransmissionTask,
   SocketController,
   Task4 as Task,
+  createSSRInquiryBridge,
   index_default as default
 };
 //# sourceMappingURL=index.mjs.map