diff --git a/messaging/src/main/java/xdi2/messaging/target/impl/CompoundMessagingTarget.java b/messaging/src/main/java/xdi2/messaging/target/impl/CompoundMessagingTarget.java
new file mode 100644
index 000000000..8918494e0
--- /dev/null
+++ b/messaging/src/main/java/xdi2/messaging/target/impl/CompoundMessagingTarget.java
@@ -0,0 +1,345 @@
+package xdi2.messaging.target.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import xdi2.core.Statement;
+import xdi2.core.exceptions.Xdi2MessagingException;
+import xdi2.messaging.Message;
+import xdi2.messaging.MessageEnvelope;
+import xdi2.messaging.MessageResult;
+import xdi2.messaging.Operation;
+import xdi2.messaging.target.ExecutionContext;
+import xdi2.messaging.target.interceptor.MessageEnvelopeInterceptor;
+import xdi2.messaging.target.interceptor.MessageInterceptor;
+import xdi2.messaging.target.interceptor.OperationInterceptor;
+import xdi2.messaging.target.interceptor.ResultInterceptor;
+
+/**
+ * A messaging target that can combine multiple other messaging targets.
+ * 
+ * Incoming messages will be sequentially applied to all individual targets, and
+ * a single message result will be produced.
+ * 
+ * @author markus
+ */
+public class CompoundMessagingTarget extends AbstractMessagingTarget {
+
+	private static final Log log = LogFactory.getLog(CompoundMessagingTarget.class);
+
+	public static final String MODE_ALL = "all";
+	public static final String MODE_FIRST_HANDLED = "first-handled";
+	public static final String MODE_WRITE_FIRST_HANDLED = "write-first-handled";
+
+	private String mode;
+	private List<AbstractMessagingTarget> messagingTargets;
+
+	public CompoundMessagingTarget() {
+
+		this.mode = MODE_ALL;
+		this.messagingTargets = new ArrayList<AbstractMessagingTarget> ();
+	}
+
+	@Override
+	public void init() throws Exception {
+
+		super.init();
+
+		// add compound interceptors
+
+		this.getMessageEnvelopeInterceptors().add(new CompoundMessageEnvelopeInterceptor());
+		this.getMessageInterceptors().add(new CompoundMessageInterceptor());
+		this.getOperationInterceptors().add(new CompoundOperationInterceptor());
+		this.getResultInterceptors().add(new CompoundResultInterceptor());
+	}
+
+	/**
+	 * We execute an operation by letting all our individual messaging targets
+	 * execute it.
+	 */
+	public boolean execute(Operation operation, MessageResult messageResult, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+		boolean handled = false;
+
+		for (int i=0; i<CompoundMessagingTarget.this.messagingTargets.size(); i++) {
+
+			AbstractMessagingTarget messagingTarget = CompoundMessagingTarget.this.messagingTargets.get(i);
+
+			try {
+
+				if (messagingTarget.execute(operation, messageResult, executionContext)) handled = true;
+				if (handled && operation.isWriteOperation() && this.mode.equalsIgnoreCase(MODE_WRITE_FIRST_HANDLED)) break;
+				if (handled && this.mode.equalsIgnoreCase(MODE_FIRST_HANDLED)) break;
+			} catch (Exception ex) { 
+
+				if (ex instanceof Xdi2MessagingException) 
+					throw (Xdi2MessagingException) ex;
+				else 
+					throw new Xdi2MessagingException(ex);
+			}
+		}
+
+		return handled;
+	}
+
+	public String getMode() {
+
+		return this.mode;
+	}
+
+	public void setMode(String mode) {
+
+		this.mode = mode;
+	}
+
+	public List<AbstractMessagingTarget> getMessagingTargets() {
+
+		return this.messagingTargets;
+	}
+
+	public void setMessagingTargets(List<AbstractMessagingTarget> messagingTargets) {
+
+		this.messagingTargets = messagingTargets;
+	}
+
+	private class CompoundMessageEnvelopeInterceptor implements MessageEnvelopeInterceptor {
+
+		public boolean before(MessageEnvelope messageEnvelope, MessageResult messageResult, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+			// execute all message envelope interceptors
+
+			for (int i=0; i<CompoundMessagingTarget.this.messagingTargets.size(); i++) {
+
+				AbstractMessagingTarget messagingTarget = CompoundMessagingTarget.this.messagingTargets.get(i);
+
+				for (MessageEnvelopeInterceptor messageEnvelopeInterceptor : messagingTarget.getMessageEnvelopeInterceptors()) {
+
+					if (log.isDebugEnabled()) log.debug("Executing message envelope interceptor " + messageEnvelopeInterceptor.getClass().getSimpleName() + " (before).");
+
+					if (messageEnvelopeInterceptor.before(messageEnvelope, messageResult, executionContext)) {
+
+						if (log.isDebugEnabled()) log.debug("Message envelope has been fully handled by interceptor " + messageEnvelopeInterceptor.getClass().getSimpleName() + ".");
+						return true;
+					}
+				}
+			}
+
+			return false;
+		}
+
+		public boolean after(MessageEnvelope messageEnvelope, MessageResult messageResult, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+			// execute all message envelope interceptors
+
+			for (int i=0; i<CompoundMessagingTarget.this.messagingTargets.size(); i++) {
+
+				AbstractMessagingTarget messagingTarget = CompoundMessagingTarget.this.messagingTargets.get(i);
+
+				for (MessageEnvelopeInterceptor messageEnvelopeInterceptor : messagingTarget.getMessageEnvelopeInterceptors()) {
+
+					if (log.isDebugEnabled()) log.debug("Executing message envelope interceptor " + messageEnvelopeInterceptor.getClass().getSimpleName() + " (after).");
+
+					if (messageEnvelopeInterceptor.after(messageEnvelope, messageResult, executionContext)) {
+
+						if (log.isDebugEnabled()) log.debug("Message envelope has been fully handled by interceptor " + messageEnvelopeInterceptor.getClass().getSimpleName() + ".");
+						return true;
+					}
+				}
+			}
+
+			return false;
+		}
+
+		public void exception(MessageEnvelope messageEnvelope, MessageResult messageResult, ExecutionContext executionContext, Exception ex) {
+
+			// execute all message envelope interceptors
+
+			for (int i=0; i<CompoundMessagingTarget.this.messagingTargets.size(); i++) {
+
+				AbstractMessagingTarget messagingTarget = CompoundMessagingTarget.this.messagingTargets.get(i);
+
+				for (MessageEnvelopeInterceptor messageEnvelopeInterceptor : messagingTarget.getMessageEnvelopeInterceptors()) {
+
+					if (log.isDebugEnabled()) log.debug("Executing message envelope interceptor " + messageEnvelopeInterceptor.getClass().getSimpleName() + " (exception).");
+
+					messageEnvelopeInterceptor.exception(messageEnvelope, messageResult, executionContext, ex);
+				}
+			}
+		}
+	}
+
+	private class CompoundMessageInterceptor implements MessageInterceptor {
+
+		public boolean before(Message message, MessageResult messageResult, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+			// execute all message interceptors
+
+			for (int i=0; i<CompoundMessagingTarget.this.messagingTargets.size(); i++) {
+
+				AbstractMessagingTarget messagingTarget = CompoundMessagingTarget.this.messagingTargets.get(i);
+
+				for (MessageInterceptor messageInterceptor : messagingTarget.getMessageInterceptors()) {
+
+					if (log.isDebugEnabled()) log.debug("Executing message interceptor " + messageInterceptor.getClass().getSimpleName() + " (before).");
+
+					if (messageInterceptor.before(message, messageResult, executionContext)) {
+
+						if (log.isDebugEnabled()) log.debug("Message has been fully handled by interceptor " + messageInterceptor.getClass().getSimpleName() + ".");
+						return true;
+					}
+				}
+			}
+
+			return false;
+		}
+
+		public boolean after(Message message, MessageResult messageResult, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+			// execute all message interceptors
+
+			for (int i=0; i<CompoundMessagingTarget.this.messagingTargets.size(); i++) {
+
+				AbstractMessagingTarget messagingTarget = CompoundMessagingTarget.this.messagingTargets.get(i);
+
+				for (MessageInterceptor messageInterceptor : messagingTarget.getMessageInterceptors()) {
+
+					if (log.isDebugEnabled()) log.debug("Executing message interceptor " + messageInterceptor.getClass().getSimpleName() + " (after).");
+
+					if (messageInterceptor.after(message, messageResult, executionContext)) {
+
+						if (log.isDebugEnabled()) log.debug("Message has been fully handled by interceptor " + messageInterceptor.getClass().getSimpleName() + ".");
+						return true;
+					}
+				}
+			}
+
+			return false;
+		}
+	}
+
+	private class CompoundOperationInterceptor implements OperationInterceptor {
+
+		public boolean before(Operation operation, MessageResult messageResult, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+			// execute all operation interceptors
+
+			for (int i=0; i<CompoundMessagingTarget.this.messagingTargets.size(); i++) {
+
+				AbstractMessagingTarget messagingTarget = CompoundMessagingTarget.this.messagingTargets.get(i);
+
+				for (OperationInterceptor operationInterceptor : messagingTarget.getOperationInterceptors()) {
+
+					if (log.isDebugEnabled()) log.debug("Executing operation interceptor " + operationInterceptor.getClass().getSimpleName() + " (before).");
+
+					if (operationInterceptor.before(operation, messageResult, executionContext)) {
+
+						if (log.isDebugEnabled()) log.debug("Operation has been fully handled by interceptor " + operationInterceptor.getClass().getSimpleName() + ".");
+						return true;
+					}
+				}
+			}
+
+			return false;
+		}
+
+		public boolean after(Operation operation, MessageResult messageResult, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+			// execute all operation interceptors
+
+			for (int i=0; i<CompoundMessagingTarget.this.messagingTargets.size(); i++) {
+
+				AbstractMessagingTarget messagingTarget = CompoundMessagingTarget.this.messagingTargets.get(i);
+
+				for (OperationInterceptor operationInterceptor : messagingTarget.getOperationInterceptors()) {
+
+					if (log.isDebugEnabled()) log.debug("Executing operation interceptor " + operationInterceptor.getClass().getSimpleName() + " (after).");
+
+					if (operationInterceptor.after(operation, messageResult, executionContext)) {
+
+						if (log.isDebugEnabled()) log.debug("Operation has been fully handled by interceptor " + operationInterceptor.getClass().getSimpleName() + ".");
+						return true;
+					}
+				}
+			}
+
+			return false;
+		}
+	}
+
+	private class CompoundResultInterceptor implements ResultInterceptor {
+
+		public boolean exclude(Statement statement, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+			// execute all result interceptors
+
+			for (int i=0; i<CompoundMessagingTarget.this.messagingTargets.size(); i++) {
+
+				AbstractMessagingTarget messagingTarget = CompoundMessagingTarget.this.messagingTargets.get(i);
+
+				for (ResultInterceptor resultInterceptor : messagingTarget.getResultInterceptors()) {
+
+					if (log.isDebugEnabled()) log.debug("Executing result interceptor " + resultInterceptor.getClass().getSimpleName() + " on address " + statement + ".");
+
+					if (resultInterceptor.exclude(statement, executionContext)) {
+
+						if (log.isDebugEnabled()) log.debug(this.getClass().getSimpleName() + ": Result " + statement + " has been excluded by interceptor " + resultInterceptor.getClass().getSimpleName() + ".");
+						return true;
+					}
+				}
+			}
+
+			return false;
+		}
+	}
+
+	@Override
+	public void before(MessageEnvelope messageEnvelope, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+		super.before(messageEnvelope, executionContext);
+
+		for (AbstractMessagingTarget messagingTarget : this.messagingTargets) messagingTarget.before(messageEnvelope, executionContext);
+	}
+
+	@Override
+	public void before(Message message, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+		super.before(message, executionContext);
+
+		for (AbstractMessagingTarget messagingTarget : this.messagingTargets) messagingTarget.before(message, executionContext);
+	}
+
+	@Override
+	public void before(Operation operation, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+		super.before(operation, executionContext);
+
+		for (AbstractMessagingTarget messagingTarget : this.messagingTargets) messagingTarget.before(operation, executionContext);
+	}
+
+	@Override
+	public void after(MessageEnvelope messageEnvelope, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+		super.after(messageEnvelope, executionContext);
+
+		for (AbstractMessagingTarget messagingTarget : this.messagingTargets) messagingTarget.after(messageEnvelope, executionContext);
+	}
+
+	@Override
+	public void after(Message message, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+		super.after(message, executionContext);
+
+		for (AbstractMessagingTarget messagingTarget : this.messagingTargets) messagingTarget.after(message, executionContext);
+	}
+
+	@Override
+	public void after(Operation operation, ExecutionContext executionContext) throws Xdi2MessagingException {
+
+		super.after(operation, executionContext);
+
+		for (AbstractMessagingTarget messagingTarget : this.messagingTargets) messagingTarget.after(operation, executionContext);
+	}
+}
diff --git a/pom.xml b/pom.xml
index fa6cb3b84..d7c9b3d59 100644
--- a/pom.xml
+++ b/pom.xml
@@ -12,6 +12,7 @@
 		<module>core</module>
 		<module>messaging</module>
 		<module>client</module>
+		<module>server-logic</module>
 		<module>server</module>
 		<module>p2p</module>
 		<module>webtools</module>
diff --git a/server-logic/.classpath b/server-logic/.classpath
new file mode 100644
index 000000000..756245a64
--- /dev/null
+++ b/server-logic/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER"/>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>
diff --git a/server-logic/.gitignore b/server-logic/.gitignore
new file mode 100644
index 000000000..ea8c4bf7f
--- /dev/null
+++ b/server-logic/.gitignore
@@ -0,0 +1 @@
+/target
diff --git a/server-logic/.project b/server-logic/.project
new file mode 100644
index 000000000..de152de6d
--- /dev/null
+++ b/server-logic/.project
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>xdi2-server-logic</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/server-logic/.settings/org.eclipse.jdt.core.prefs b/server-logic/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 000000000..02b23c61e
--- /dev/null
+++ b/server-logic/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,13 @@
+#Sun Feb 26 14:46:59 CET 2012
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.6
diff --git a/server-logic/.settings/org.eclipse.m2e.core.prefs b/server-logic/.settings/org.eclipse.m2e.core.prefs
new file mode 100644
index 000000000..a81eab87e
--- /dev/null
+++ b/server-logic/.settings/org.eclipse.m2e.core.prefs
@@ -0,0 +1,5 @@
+#Sun Feb 26 14:46:59 CET 2012
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1
diff --git a/server-logic/pom.xml b/server-logic/pom.xml
new file mode 100644
index 000000000..27caff996
--- /dev/null
+++ b/server-logic/pom.xml
@@ -0,0 +1,42 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+	<modelVersion>4.0.0</modelVersion>
+	<artifactId>xdi2-server-logic</artifactId>
+	<packaging>jar</packaging>
+	<name>xdi2-server-logic</name>
+
+	<parent>
+		<groupId>xdi2</groupId>
+		<artifactId>xdi2</artifactId>
+		<version>0.1-SNAPSHOT</version>
+	</parent>
+
+	<dependencies>
+		<dependency>
+			<groupId>javax.servlet</groupId>
+			<artifactId>servlet-api</artifactId>
+			<version>2.5</version>
+			<scope>provided</scope>
+		</dependency>
+		<dependency>
+			<groupId>xdi2</groupId>
+			<artifactId>xdi2-messaging</artifactId>
+			<version>0.1-SNAPSHOT</version>
+			<scope>compile</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-web</artifactId>
+			<version>3.0.0.RELEASE</version>
+			<scope>compile</scope>
+			<exclusions>
+				<exclusion>
+					<groupId>commons-logging</groupId>
+					<artifactId>commons-logging</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+	</dependencies>
+
+</project>
diff --git a/server/src/main/java/xdi2/server/EndpointRegistry.java b/server-logic/src/main/java/xdi2/server/EndpointRegistry.java
similarity index 100%
rename from server/src/main/java/xdi2/server/EndpointRegistry.java
rename to server-logic/src/main/java/xdi2/server/EndpointRegistry.java
diff --git a/server/src/main/java/xdi2/server/EndpointServlet.java b/server-logic/src/main/java/xdi2/server/EndpointServlet.java
similarity index 96%
rename from server/src/main/java/xdi2/server/EndpointServlet.java
rename to server-logic/src/main/java/xdi2/server/EndpointServlet.java
index 9bc43cf1c..b547fb75e 100644
--- a/server/src/main/java/xdi2/server/EndpointServlet.java
+++ b/server-logic/src/main/java/xdi2/server/EndpointServlet.java
@@ -372,7 +372,6 @@ private MessageEnvelope readFromBody(HttpServletRequest request, HttpServletResp
 		reader = XDIReaderRegistry.forMimeType(inputMimeType);
 
 		if (reader == null) reader = XDIReaderRegistry.getDefault();
-		if (reader == null) return(null);
 
 		// read everything into an in-memory XDI graph (a message envelope)
 
@@ -451,7 +450,6 @@ private void sendResult(MessageResult messageResult, HttpServletRequest request,
 		}
 
 		if (writer == null) writer = XDIWriterRegistry.getDefault();
-		if (writer == null);
 
 		// send out the message result
 
diff --git a/server/src/main/java/xdi2/server/ServletExecutionContext.java b/server-logic/src/main/java/xdi2/server/ServletExecutionContext.java
similarity index 100%
rename from server/src/main/java/xdi2/server/ServletExecutionContext.java
rename to server-logic/src/main/java/xdi2/server/ServletExecutionContext.java
diff --git a/server/src/main/java/xdi2/server/package.html b/server-logic/src/main/java/xdi2/server/package.html
similarity index 100%
rename from server/src/main/java/xdi2/server/package.html
rename to server-logic/src/main/java/xdi2/server/package.html
diff --git a/server/.classpath b/server/.classpath
index f34989b74..d60bed031 100644
--- a/server/.classpath
+++ b/server/.classpath
@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" output="target/classes" path="src/main/java"/>
 	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources"/>
 	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
diff --git a/server/pom.xml b/server/pom.xml
index cd854bb08..5e3271c91 100644
--- a/server/pom.xml
+++ b/server/pom.xml
@@ -18,9 +18,6 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-war-plugin</artifactId>
 				<version>2.2</version>
-				<configuration>
-					<attachClasses>true</attachClasses>
-				</configuration>
 			</plugin>
 			<plugin>
 				<groupId>org.mortbay.jetty</groupId>
@@ -72,30 +69,12 @@
 	</build>
 
 	<dependencies>
-		<dependency>
-			<groupId>javax.servlet</groupId>
-			<artifactId>servlet-api</artifactId>
-			<version>2.5</version>
-			<scope>provided</scope>
-		</dependency>
 		<dependency>
 			<groupId>xdi2</groupId>
-			<artifactId>xdi2-messaging</artifactId>
+			<artifactId>xdi2-server-logic</artifactId>
 			<version>0.1-SNAPSHOT</version>
 			<scope>compile</scope>
 		</dependency>
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-web</artifactId>
-			<version>3.0.0.RELEASE</version>
-			<scope>compile</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>commons-logging</groupId>
-					<artifactId>commons-logging</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
 	</dependencies>
 
 </project>
diff --git a/server/xdi2-file/graph.xdi b/server/xdi2-file/graph.xdi
deleted file mode 100644
index 69a88e3b6..000000000
--- a/server/xdi2-file/graph.xdi
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/webtools/pom.xml b/webtools/pom.xml
index f1b177d69..bf0119ac6 100644
--- a/webtools/pom.xml
+++ b/webtools/pom.xml
@@ -95,9 +95,8 @@
 		</dependency>
 		<dependency>
 			<groupId>xdi2</groupId>
-			<artifactId>xdi2-server</artifactId>
+			<artifactId>xdi2-server-logic</artifactId>
 			<version>0.1-SNAPSHOT</version>
-			<classifier>classes</classifier>
 			<scope>compile</scope>
 		</dependency>
 	</dependencies>