diff --git a/extensions/persist/src/com/google/inject/persist/PersistFilter.java b/extensions/persist/src/com/google/inject/persist/PersistFilter.java
new file mode 100644
index 0000000..2fc7a5f
--- /dev/null
+++ b/extensions/persist/src/com/google/inject/persist/PersistFilter.java
@@ -0,0 +1,94 @@
+/**
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.inject.persist;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.io.IOException;
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+
+/**
+ * Apply this filter to enable the HTTP Request unit of work and to have
+ * guice-persist manage the lifecycle of active units of work.
+ * The filter automatically starts and stops the relevant {@link PersistService}
+ * upon {@link javax.servlet.Filter#init(javax.servlet.FilterConfig)} and
+ * {@link javax.servlet.Filter#destroy()} respectively.
+ *
+ * <p> To be able to use the open session-in-view pattern (i.e. work per request),
+ * register this filter <b>once</b> in your Guice {@code ServletModule}. It is
+ * important that you register this filter before any other filter.
+ *
+ * For multiple providers, you should register this filter once per provider, inside
+ * a private module for each persist module installed (this must be the same private
+ * module where the specific persist module is itself installed).
+ *
+ * <p>
+ * Example configuration:
+ * <pre>{@code
+ *  public class MyModule extends ServletModule {
+ *    public void configureServlets() {
+ *      filter("/*").through(PersistFilter.class);
+ *
+ *      serve("/index.html").with(MyHtmlServlet.class);
+ *      // Etc.
+ *    }
+ *  }
+ * }</pre>
+ * <p>
+ * This filter is thread safe and allows you to create injectors concurrently
+ * and deploy multiple guice-persist modules within the same injector, or even
+ * multiple injectors with persist modules withing the same JVM or web app.
+ * <p>
+ * This filter requires the Guice Servlet extension.
+ *
+ * @author Dhanji R. Prasanna (dhanji@gmail.com)
+ */
+@Singleton
+public final class PersistFilter implements Filter {
+  private final UnitOfWork unitOfWork;
+  private final PersistService persistService;
+
+  @Inject
+  public PersistFilter(UnitOfWork unitOfWork, PersistService persistService) {
+    this.unitOfWork = unitOfWork;
+    this.persistService = persistService;
+  }
+
+  public void init(FilterConfig filterConfig) throws ServletException {
+    persistService.start();
+  }
+
+  public void destroy() {
+    persistService.stop();
+  }
+
+  public void doFilter(final ServletRequest servletRequest, final ServletResponse servletResponse,
+      final FilterChain filterChain) throws IOException, ServletException {
+
+    unitOfWork.begin();
+    try {
+      filterChain.doFilter(servletRequest, servletResponse);
+    } finally {
+      unitOfWork.end();
+    }
+  }
+}
diff --git a/extensions/persist/src/com/google/inject/persist/PersistModule.java b/extensions/persist/src/com/google/inject/persist/PersistModule.java
index ddbad19..6703cb5 100644
--- a/extensions/persist/src/com/google/inject/persist/PersistModule.java
+++ b/extensions/persist/src/com/google/inject/persist/PersistModule.java
@@ -1,70 +1,44 @@
+/**
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package com.google.inject.persist;
 
 import com.google.inject.AbstractModule;
-import com.google.inject.BindingAnnotation;
-import com.google.inject.internal.util.Preconditions;
 import static com.google.inject.matcher.Matchers.annotatedWith;
 import static com.google.inject.matcher.Matchers.any;
-import java.lang.annotation.Annotation;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
 import org.aopalliance.intercept.MethodInterceptor;
 
 /**
  * Install this module to add guice-persist library support for JPA persistence
  * providers.
  *
- * @author dhanji@google.com (Dhanji R. Prasanna)
+ * @author dhanji@gmail.com (Dhanji R. Prasanna)
  */
 public abstract class PersistModule extends AbstractModule {
-  private Class<? extends Annotation> unitOfWork;
-  private Class<? extends Annotation> transactional;
 
   @Override
   protected final void configure() {
     configurePersistence();
 
-    if (null == unitOfWork) {
-      // We bind this as the "Default" work manager if no custom unit of work is used.
-      bind(WorkManager.class).to(getWorkManager());
-      unitOfWork = UnitOfWork.class;
-    }
-    if (null == transactional) {
-      transactional = Transactional.class;
-    }
-
-    // NOTE(dhanji): Bind work-specific work manager + transaction interceptors.
-    // We permit the default work manager to be bound to both the default work
-    // annotation @UnitOfWork, and without any annotation. Default is defined as
-    // any persistence module without a custom unit of work annotation. In a single
-    // module system, the single module would be the default (most typical apps).
-    bind(WorkManager.class).annotatedWith(unitOfWork).to(getWorkManager());
-    bindInterceptor(any(), annotatedWith(transactional), getTransactionInterceptor());
+    requireBinding(PersistService.class);
+    requireBinding(UnitOfWork.class);
+    bindInterceptor(any(), annotatedWith(Transactional.class), getTransactionInterceptor());
   }
 
   protected abstract void configurePersistence();
 
-  protected abstract Class<? extends WorkManager> getWorkManager();
-
   protected abstract MethodInterceptor getTransactionInterceptor();
-
-  protected final void setUnitOfWork(Class<? extends Annotation> unitOfWork) {
-    Preconditions.checkArgument(null != unitOfWork,
-        "Must specify a non-null unit of work.");
-    this.unitOfWork = unitOfWork;
-  }
-
-  protected final void setTransactional(Class<? extends Annotation> transactional) {
-    Preconditions.checkArgument(null != unitOfWork,
-        "Must specify a non-null transactional annotation.");
-    this.transactional = transactional;
-  }
-
-  /**
-   * @author dhanji@google.com (Dhanji R. Prasanna)
-   */
-  @Retention(RetentionPolicy.RUNTIME)
-  @BindingAnnotation
-  public static @interface Persist {
-  }
 }
diff --git a/extensions/persist/src/com/google/inject/persist/PersistService.java b/extensions/persist/src/com/google/inject/persist/PersistService.java
new file mode 100644
index 0000000..85d4b35
--- /dev/null
+++ b/extensions/persist/src/com/google/inject/persist/PersistService.java
@@ -0,0 +1,44 @@
+/**
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.inject.persist;
+
+/**
+ * Persistence provider service. Use this to manage the overall
+ * startup and stop of the persistence module(s).
+ *
+ * TODO(dhanji): Integrate with Service API when appropriate.
+ *
+ * @author dhanji@gmail.com (Dhanji R. Prasanna)
+ */
+public interface PersistService {
+
+  /**
+   * Starts the underlying persistence engine and makes guice-persist ready for
+   * use. For instance, with JPA, it creates an EntityManagerFactory and may
+   * open connection pools. This method must be called by your code prior to
+   * using any guice-persist or JPA artifacts. If already started,
+   * calling this method does nothing, if already stopped, it also does
+   * nothing.
+   */
+  void start();
+
+  /**
+   * Stops the underlying persistence engine. For instance, with JPA, it
+   * closes the {@code EntityManagerFactory}. If already stopped, calling this
+   * method does nothing. If not yet started, it also does nothing.
+   */
+  void stop();
+}
diff --git a/extensions/persist/src/com/google/inject/persist/PersistenceFilter.java b/extensions/persist/src/com/google/inject/persist/PersistenceFilter.java
deleted file mode 100644
index d427c05..0000000
--- a/extensions/persist/src/com/google/inject/persist/PersistenceFilter.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/**
- * Copyright (C) 2010 Google, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.inject.persist;
-
-import com.google.inject.Inject;
-import com.google.inject.Singleton;
-import java.io.IOException;
-import javax.servlet.Filter;
-import javax.servlet.FilterChain;
-import javax.servlet.FilterConfig;
-import javax.servlet.ServletException;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-
-/**
- * Apply this filter to enable the HTTP Request unit of work and to have
- * guice-persist manage the lifecycle of all active (module-installed)
- * {@link WorkManager} instances. The filter automatically starts and
- * stops all registered {@link WorkManager} instances upon {@link
- * javax.servlet.Filter#init(javax.servlet.FilterConfig)} and {@link
- * javax.servlet.Filter#destroy()}.
- *
- * <p> To be able to use the open session-in-view pattern (i.e. work per request),
- * register this filter <b>once</b> in your Guice {@code ServletModule}. It is
- * important that you register this filter before any other filter.
- *
- * <p>
- * Example configuration:
- * <pre>{@code
- *  public class MyModule extends ServletModule {
- *    public void configureServlets() {
- *      filter("/*").through(PersistenceFilter.class);
- *
- *      serve("/index.html").with(MyHtmlServlet.class);
- *      // Etc.
- *    }
- *  }
- * }</pre>
- * <p>
- * This filter will make sure to initialize and shutdown the underlying
- * persistence engine on filter {@code init()} and {@code destroy()}
- * respectively. Note that if you have multiple modules, this filter will
- * only start the "default" module, i.e. the {@code WorkManager} that is not
- * bound to any annotation.
- * <p>
- * Even though all mutable state is package local, this filter is thread safe.
- * This allows you to create injectors concurrently and deploy multiple
- * guice-persist applications within the same JVM or servlet container.
- *
- * @author Dhanji R. Prasanna (dhanji@gmail.com)
- */
-@Singleton
-public final class PersistenceFilter implements Filter {
-  private final WorkManager workManager;
-
-  @Inject
-  public PersistenceFilter(WorkManager workManager) {
-    this.workManager = workManager;
-  }
-
-  public void init(FilterConfig filterConfig) throws ServletException {
-    workManager.startPersistence();
-  }
-
-  public void destroy() {
-    workManager.shutdownPersistence();
-  }
-
-  public void doFilter(final ServletRequest servletRequest, final ServletResponse servletResponse,
-      final FilterChain filterChain) throws IOException, ServletException {
-    filterChain.doFilter(servletRequest, servletResponse);
-  }
-}
diff --git a/extensions/persist/src/com/google/inject/persist/Transactional.java b/extensions/persist/src/com/google/inject/persist/Transactional.java
index 089275c..02526b4 100644
--- a/extensions/persist/src/com/google/inject/persist/Transactional.java
+++ b/extensions/persist/src/com/google/inject/persist/Transactional.java
@@ -25,16 +25,15 @@
 /**
  * <p> Any method or class marked with this annotation will be considered for transactionality.
  * Consult the documentation on http://code.google.com/p/google-guice for detailed semantics.
- * Marking a method {@code @Transactional} will work with the default configuration as expected.
- *  Any classes marked {@code @Transactional} will only work if you specify the
- *  {@code forAll(Matchers.annotatedWith(Transactional.class), Matchers.any()} clause in your
- * guice-persist module configuration.
- *
- * Class level {@code @Transactional} allows you to specify transaction semantics for all
- * non-private methods in the class once at the top. You can optionally override it on a
- * per-method basis too. However, this means that classes not marked {@code @Transactional}
- *  but with methods marked {@code @Transactional} will *not* be intercepted for transaction
- *  wrapping.
+ * Marking a method {@code @Transactional} will start a new transaction before the method
+ * executes and commit it after the method returns.
+ * <p>
+ * If the method throws an exception, the transaction will be rolled back <em>unless</em>
+ * you have specifically requested not to in the {@link #ignore()} clause.
+ * <p>
+ * Similarly, the set of exceptions that will trigger a rollback can be defined in
+ * the {@link #rollbackOn()} clause. By default, only unchecked exceptions trigger a
+ * rollback.
  *
  * @author Dhanji R. Prasanna (dhanji@gmail.com)
  */
diff --git a/extensions/persist/src/com/google/inject/persist/UnitOfWork.java b/extensions/persist/src/com/google/inject/persist/UnitOfWork.java
old mode 100644
new mode 100755
index aacfadc..061a6ab
--- a/extensions/persist/src/com/google/inject/persist/UnitOfWork.java
+++ b/extensions/persist/src/com/google/inject/persist/UnitOfWork.java
@@ -1,18 +1,57 @@
+/**
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package com.google.inject.persist;
 
-import com.google.inject.BindingAnnotation;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
 /**
- * The Default unit of work binding annotation used to bind persistence
- * artifacts to. You may also place this annotation on methods to intercept
- * and wrap them with a unit of work (i.e. start and end work around methods).
- * This is analogous to starting an ending transactions but at a coarser
- * granularity. For example, in JPA a unit of work would span a single
- * {@code EntityManager}'s lifespan. 
+ * This interface is used to gain manual control over the unit of work. This is mostly to do
+ * work in non-request, non-transactional threads. Or where more fine-grained control over the unit
+ * of work is required. Starting and ending a unit of work directly corresponds to opening and
+ * closing a {@code Session}, {@code EntityManager} or {@code ObjectContainer} respectively.
+ * <p> The
+ * Unit of Work referred to by UnitOfWork will always be local to the calling thread. Be careful to
+ * end() in a finally block. Neither JPA, nor Hibernate supports threadsafe sessions (reasoning
+ * behind thread-locality of Unit of Work semantics).
+ *
+ * <ul>
+ *   <li>Using UnitOfWork with the PersistFilter inside a request is not recommended.</li>
+ *   <li>Using UnitOfWork with session-per-txn strategy is not terribly clever either.</li>
+ *   <li>Using UnitOfWork with session-per-request strategy but *outside* a request (i.e. in a
+ *       background or bootstrap thread) is probably a good use case.</li>
+ *  </ul>
+ *
+ * @author Dhanji R. Prasanna (dhanji@gmail com)
  */
-@Retention(RetentionPolicy.RUNTIME)
-@BindingAnnotation
-public @interface UnitOfWork {
+public interface UnitOfWork {
+
+  /**
+   * Starts a Unit Of Work. Underneath, causes a session to the data layer to be opened. If there
+   * is already one open, the invocation will do nothing. In this way, you can define arbitrary
+   * units-of-work that nest within one another safely.
+   *
+   * Transaction semantics are not affected.
+   */
+  void begin();
+
+  /**
+   * Declares an end to the current Unit of Work. Underneath, causes any open session to the data
+   * layer to close. If there is no Unit of work open, then the call returns silently. You can
+   * safely invoke end() repeatedly.
+   * <p>
+   * Transaction semantics are not affected.
+   */
+  void end();
 }
diff --git a/extensions/persist/src/com/google/inject/persist/WorkManager.java b/extensions/persist/src/com/google/inject/persist/WorkManager.java
deleted file mode 100755
index 32cfe71..0000000
--- a/extensions/persist/src/com/google/inject/persist/WorkManager.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/**
- * Copyright (C) 2010 Google, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.inject.persist;
-
-/**
- * This interface is used to gain manual control over the unit of work. This is mostly to do
- * work in non-request, non-transactional threads. Or where more fine-grained control over the unit
- * of work is required. Starting and ending a unit of work directly corresponds to opening and
- * closing a {@code Session}, {@code EntityManager} or {@code ObjectContainer} respectively.
- * <p> The
- * Unit of Work referred to by WorkManager will always be local to the calling thread. Be careful to
- * end() in a finally block. Neither JPA, nor Hibernate supports threadsafe sessions (reasoning
- * behind thread-locality of Unit of Work semantics).
- *
- * <ul>
- *   <li>Using WorkManager with the PersistenceFilter inside a request is not recommended.</li>
- *   <li>Using WorkManager with session-per-txn strategy is not terribly clever either.</li>
- *   <li>Using WorkManager with session-per-request strategy but *outside* a request (i.e. in a
- *       background or bootstrap thread) is probably a good use case.</li>
- *  </ul>
- *
- * @author Dhanji R. Prasanna (dhanji gmail com)
- */
-public interface WorkManager {
-
-  /**
-   * Starts the underlying persistence engine and makes guice-persist ready for
-   * use. For instance, with JPA, it creates an EntityManagerFactory and may
-   * open connection pools. This method must be called by your code prior to
-   * using any guice-persist or JPA artifacts. If already started,
-   * calling this method does nothing, if already stopped, it also does
-   * nothing.
-   */
-  void startPersistence();
-
-  /**
-   * Stops the underlying persistence engine. For instance, with JPA, it
-   * closes the {@code EntityManagerFactory}. If already stopped, calling this
-   * method does nothing. If not yet started, it also does nothing.
-   */
-  void shutdownPersistence();
-
-  /**
-   * Starts a Unit Of Work. Underneath, causes a session to the data layer to be opened. If there
-   * is already one open, the invocation will do nothing. In this way, you can define arbitrary
-   * units-of-work that nest within one another safely.
-   *
-   * Transaction semantics are not affected.
-   */
-  void begin();
-
-  /**
-   * Declares an end to the current Unit of Work. Underneath, causes any open session to the data
-   * layer to close. If there is no Unit of work open, then the call returns silently. You can
-   * safely invoke end() repeatedly.
-   * <p>
-   * Transaction semantics are not affected.
-   */
-  void end();
-}
diff --git a/extensions/persist/src/com/google/inject/persist/finder/DynamicFinder.java b/extensions/persist/src/com/google/inject/persist/finder/DynamicFinder.java
index 8595917..a98158a 100644
--- a/extensions/persist/src/com/google/inject/persist/finder/DynamicFinder.java
+++ b/extensions/persist/src/com/google/inject/persist/finder/DynamicFinder.java
@@ -1,4 +1,18 @@
-// Copyright 2010 Google Inc. All Rights Reserved.
+/**
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 package com.google.inject.persist.finder;
 
@@ -7,7 +21,7 @@
 /**
  * Utility that helps you discover metadata about dynamic finder methods.
  *
- * @author dhanji@google.com (Dhanji R. Prasanna)
+ * @author dhanji@gmail.com (Dhanji R. Prasanna)
  */
 public final class DynamicFinder {
 
diff --git a/extensions/persist/src/com/google/inject/persist/finder/Finder.java b/extensions/persist/src/com/google/inject/persist/finder/Finder.java
index dde9dec..cc5f58e 100644
--- a/extensions/persist/src/com/google/inject/persist/finder/Finder.java
+++ b/extensions/persist/src/com/google/inject/persist/finder/Finder.java
@@ -24,32 +24,28 @@
 import java.util.Collection;
 
 /**
- * <p> Marks a method stub as a dynamic finder. The method is intercepted and replaced with the
- * specified HQL or JPAQL query. Provides result auto-boxing and automatic parameter binding. </p>
+ * Marks a method stub as a dynamic finder. The method is intercepted and replaced with the
+ * specified JPAQL query. Provides result auto-boxing and automatic parameter binding.
  *
  * @author Dhanji R. Prasanna (dhanji@gmail.com)
  */
 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME)
 public @interface Finder {
   /**
-   * Specify a named query's name here, typically using the {@code @NamedQuery} annotation.
-   *
-   * @return Returns the configured named query's name.
+   * Returns the configured named query's name. Specify a named query's name
+   * here. This name is typically specified in your JPA configuration.
    */
   String namedQuery() default "";
 
   /**
-   * Directly specify a query here, hql or jpaql.
-   *
-   * @return Returns the configured query string.
+   * Returns the configured query string. Directly specify a JPAQL query here.
    */
   String query() default "";
 
   /**
-   * Use this clause to specify a collection impl to autobox result lists into. The impl *must*
+   * Returns the configured autoboxing collection class.
+   * Use this clause to specify a collection impl to autobox result lists into. The impl must
    * have a default no-arg constructor and be a subclass of {@code java.util.Collection}.
-   *
-   * @return Returns the configured autoboxing collection class.
    */
   Class<? extends Collection> returnAs() default ArrayList.class;
 }
\ No newline at end of file
diff --git a/extensions/persist/src/com/google/inject/persist/finder/FirstResult.java b/extensions/persist/src/com/google/inject/persist/finder/FirstResult.java
index 9398f35..510ef1a 100644
--- a/extensions/persist/src/com/google/inject/persist/finder/FirstResult.java
+++ b/extensions/persist/src/com/google/inject/persist/finder/FirstResult.java
@@ -24,7 +24,7 @@
 /**
  * Annotate any dynamic finder method's integer argument with this to pass in
  * the index of the first result in the result set you are interested in.
- * Useful for paging result sets. Complemented by {@link NumResults}.
+ * Useful for paging result sets. Complemented by {@link MaxResults}.
  *
  * @author Dhanji R. Prasanna (dhanji@gmail.com)
  */
diff --git a/extensions/persist/src/com/google/inject/persist/finder/NumResults.java b/extensions/persist/src/com/google/inject/persist/finder/MaxResults.java
similarity index 97%
rename from extensions/persist/src/com/google/inject/persist/finder/NumResults.java
rename to extensions/persist/src/com/google/inject/persist/finder/MaxResults.java
index c577b4a..a62aa28 100644
--- a/extensions/persist/src/com/google/inject/persist/finder/NumResults.java
+++ b/extensions/persist/src/com/google/inject/persist/finder/MaxResults.java
@@ -30,5 +30,5 @@
  */
 @Target(ElementType.PARAMETER)
 @Retention(RetentionPolicy.RUNTIME)
-public @interface NumResults {
+public @interface MaxResults {
 }
diff --git a/extensions/persist/src/com/google/inject/persist/finder/package-info.java b/extensions/persist/src/com/google/inject/persist/finder/package-info.java
index 2079221..514a54f 100644
--- a/extensions/persist/src/com/google/inject/persist/finder/package-info.java
+++ b/extensions/persist/src/com/google/inject/persist/finder/package-info.java
@@ -1,4 +1,4 @@
 /**
- * Dynamic Finder API.
+ * Dynamic Finder API for Guice Persist.
  */
 package com.google.inject.persist.finder;
\ No newline at end of file
diff --git a/extensions/persist/src/com/google/inject/persist/finder/NumResults.java b/extensions/persist/src/com/google/inject/persist/jpa/Jpa.java
similarity index 62%
copy from extensions/persist/src/com/google/inject/persist/finder/NumResults.java
copy to extensions/persist/src/com/google/inject/persist/jpa/Jpa.java
index c577b4a..c2f6d1d 100644
--- a/extensions/persist/src/com/google/inject/persist/finder/NumResults.java
+++ b/extensions/persist/src/com/google/inject/persist/jpa/Jpa.java
@@ -1,34 +1,29 @@
-/**
- * Copyright (C) 2010 Google, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.inject.persist.finder;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotate any dynamic finder method's integer argument with this to pass in
- * the maximum size of returned result window. Usefule for paging result sets.
- * Complement of {@link FirstResult}.
- *
- * @author Dhanji R. Prasanna (dhanji@gmail.com)
- */
-@Target(ElementType.PARAMETER)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface NumResults {
-}
+/**
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.inject.persist.jpa;
+
+import com.google.inject.BindingAnnotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * A binding annotation for internal JPA module properties.
+ *
+ * @author dhanji@gmail.com (Dhanji R. Prasanna)
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@BindingAnnotation @interface Jpa {}
diff --git a/extensions/persist/src/com/google/inject/persist/jpa/JpaFinderProxy.java b/extensions/persist/src/com/google/inject/persist/jpa/JpaFinderProxy.java
index 2f883ba..614bff9 100644
--- a/extensions/persist/src/com/google/inject/persist/jpa/JpaFinderProxy.java
+++ b/extensions/persist/src/com/google/inject/persist/jpa/JpaFinderProxy.java
@@ -20,7 +20,7 @@
 import com.google.inject.name.Named;
 import com.google.inject.persist.finder.Finder;
 import com.google.inject.persist.finder.FirstResult;
-import com.google.inject.persist.finder.NumResults;
+import com.google.inject.persist.finder.MaxResults;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
@@ -39,12 +39,12 @@
  *
  * @author Dhanji R. Prasanna (dhanji@gmail.com)
  */
-class JpaFinderInterceptor implements MethodInterceptor {
+class JpaFinderProxy implements MethodInterceptor {
   private final Map<Method, FinderDescriptor> finderCache
       = new ConcurrentHashMap<Method, FinderDescriptor>();
   private final Provider<EntityManager> emProvider;
 
-  public JpaFinderInterceptor(Provider<EntityManager> emProvider) {
+  public JpaFinderProxy(Provider<EntityManager> emProvider) {
     this.emProvider = emProvider;
   }
 
@@ -52,7 +52,7 @@
     EntityManager em = emProvider.get();
 
     //obtain a cached finder descriptor (or create a new one)
-    JpaFinderInterceptor.FinderDescriptor finderDescriptor = getFinderDescriptor(methodInvocation);
+    JpaFinderProxy.FinderDescriptor finderDescriptor = getFinderDescriptor(methodInvocation);
 
     Object result = null;
 
@@ -65,18 +65,18 @@
     }
 
     //depending upon return type, decorate or return the result as is
-    if (JpaFinderInterceptor.ReturnType.PLAIN.equals(finderDescriptor.returnType)) {
+    if (JpaFinderProxy.ReturnType.PLAIN.equals(finderDescriptor.returnType)) {
       result = jpaQuery.getSingleResult();
-    } else if (JpaFinderInterceptor.ReturnType.COLLECTION.equals(finderDescriptor.returnType)) {
+    } else if (JpaFinderProxy.ReturnType.COLLECTION.equals(finderDescriptor.returnType)) {
       result = getAsCollection(finderDescriptor, jpaQuery.getResultList());
-    } else if (JpaFinderInterceptor.ReturnType.ARRAY.equals(finderDescriptor.returnType)) {
+    } else if (JpaFinderProxy.ReturnType.ARRAY.equals(finderDescriptor.returnType)) {
       result = jpaQuery.getResultList().toArray();
     }
 
     return result;
   }
 
-  private Object getAsCollection(JpaFinderInterceptor.FinderDescriptor finderDescriptor,
+  private Object getAsCollection(JpaFinderProxy.FinderDescriptor finderDescriptor,
       List results) {
     Collection<?> collection;
     try {
@@ -100,7 +100,7 @@
   }
 
   private void bindQueryNamedParameters(Query hibernateQuery,
-      JpaFinderInterceptor.FinderDescriptor descriptor, Object[] arguments) {
+      JpaFinderProxy.FinderDescriptor descriptor, Object[] arguments) {
     for (int i = 0; i < arguments.length; i++) {
       Object argument = arguments[i];
       Object annotation = descriptor.parameterAnnotations[i];
@@ -114,14 +114,14 @@
         hibernateQuery.setParameter(named.value(), argument);
       } else if (annotation instanceof FirstResult) {
         hibernateQuery.setFirstResult((Integer) argument);
-      } else if (annotation instanceof NumResults) {
+      } else if (annotation instanceof MaxResults) {
         hibernateQuery.setMaxResults((Integer) argument);
       }
     }
   }
 
   private void bindQueryRawParameters(Query jpaQuery,
-      JpaFinderInterceptor.FinderDescriptor descriptor, Object[] arguments) {
+      JpaFinderProxy.FinderDescriptor descriptor, Object[] arguments) {
     for (int i = 0, index = 1; i < arguments.length; i++) {
       Object argument = arguments[i];
       Object annotation = descriptor.parameterAnnotations[i];
@@ -132,21 +132,21 @@
         index++;
       } else if (annotation instanceof FirstResult) {
         jpaQuery.setFirstResult((Integer) argument);
-      } else if (annotation instanceof NumResults) {
+      } else if (annotation instanceof MaxResults) {
         jpaQuery.setMaxResults((Integer) argument);
       }
     }
   }
 
-  private JpaFinderInterceptor.FinderDescriptor getFinderDescriptor(MethodInvocation invocation) {
+  private JpaFinderProxy.FinderDescriptor getFinderDescriptor(MethodInvocation invocation) {
     Method method = invocation.getMethod();
-    JpaFinderInterceptor.FinderDescriptor finderDescriptor = finderCache.get(method);
+    JpaFinderProxy.FinderDescriptor finderDescriptor = finderCache.get(method);
     if (null != finderDescriptor) {
       return finderDescriptor;
     }
 
     //otherwise reflect and cache finder info...
-    finderDescriptor = new JpaFinderInterceptor.FinderDescriptor();
+    finderDescriptor = new JpaFinderProxy.FinderDescriptor();
 
     //determine return type
     finderDescriptor.returnClass = invocation.getMethod().getReturnType();
@@ -177,7 +177,7 @@
         } else if (FirstResult.class.equals(annotationType)) {
           discoveredAnnotations[i] = annotation;
           break;
-        } else if (NumResults.class.equals(annotationType)) {
+        } else if (MaxResults.class.equals(annotationType)) {
           discoveredAnnotations[i] = annotation;
           break;
         }   //leave as null for no binding
@@ -188,7 +188,7 @@
     finderDescriptor.parameterAnnotations = discoveredAnnotations;
 
     //discover the returned collection implementation if this finder returns a collection
-    if (JpaFinderInterceptor.ReturnType.COLLECTION.equals(finderDescriptor.returnType)) {
+    if (JpaFinderProxy.ReturnType.COLLECTION.equals(finderDescriptor.returnType)) {
       finderDescriptor.returnCollectionType = finder.returnAs();
       try {
         finderDescriptor.returnCollectionTypeConstructor = finderDescriptor.returnCollectionType
@@ -218,14 +218,14 @@
     finderCache.put(method, finderDescriptor);
   }
 
-  private JpaFinderInterceptor.ReturnType determineReturnType(Class<?> returnClass) {
+  private JpaFinderProxy.ReturnType determineReturnType(Class<?> returnClass) {
     if (Collection.class.isAssignableFrom(returnClass)) {
-      return JpaFinderInterceptor.ReturnType.COLLECTION;
+      return JpaFinderProxy.ReturnType.COLLECTION;
     } else if (returnClass.isArray()) {
-      return JpaFinderInterceptor.ReturnType.ARRAY;
+      return JpaFinderProxy.ReturnType.ARRAY;
     }
 
-    return JpaFinderInterceptor.ReturnType.PLAIN;
+    return JpaFinderProxy.ReturnType.PLAIN;
   }
 
   /**
@@ -235,12 +235,12 @@
     private volatile boolean isKeyedQuery = false;
     volatile boolean isBindAsRawParameters = true;
         //should we treat the query as having ? instead of :named params
-    volatile JpaFinderInterceptor.ReturnType returnType;
+    volatile JpaFinderProxy.ReturnType returnType;
     volatile Class<?> returnClass;
     volatile Class<? extends Collection> returnCollectionType;
     volatile Constructor returnCollectionTypeConstructor;
     volatile Object[] parameterAnnotations;
-        //contract is: null = no bind, @Named = param, @FirstResult/@NumResults for paging
+        //contract is: null = no bind, @Named = param, @FirstResult/@MaxResults for paging
 
     private String query;
     private String name;
diff --git a/extensions/persist/src/com/google/inject/persist/jpa/JpaLocalTxnInterceptor.java b/extensions/persist/src/com/google/inject/persist/jpa/JpaLocalTxnInterceptor.java
index 2ec3de5..93d5b64 100644
--- a/extensions/persist/src/com/google/inject/persist/jpa/JpaLocalTxnInterceptor.java
+++ b/extensions/persist/src/com/google/inject/persist/jpa/JpaLocalTxnInterceptor.java
@@ -18,7 +18,7 @@
 
 import com.google.inject.Inject;
 import com.google.inject.persist.Transactional;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.UnitOfWork;
 import java.lang.reflect.Method;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityTransaction;
@@ -30,11 +30,11 @@
  */
 class JpaLocalTxnInterceptor implements MethodInterceptor {
 
-  @Inject // Dirty hack =(
-  private final EntityManagerProvider emProvider = null;
+  @Inject
+  private final JpaPersistService emProvider = null;
 
-  @Inject // Dirty hack =(
-  private final WorkManager workManager = null;
+  @Inject
+  private final UnitOfWork unitOfWork = null;
 
   @Transactional
   private static class Internal {}
@@ -50,8 +50,6 @@
       didWeStartWork.set(true);
     }
 
-    // TODO(dhanji): Should we make this work with other annotations?
-    // TODO(dhanji): Cache this result by method?
     Transactional transactional = readTransactionMetadata(methodInvocation);
     EntityManager em = this.emProvider.get();
 
@@ -79,7 +77,7 @@
       // Close the em if necessary (guarded so this code doesn't run unless catch fired).
       if (null != didWeStartWork.get() && !txn.isActive()) {
         didWeStartWork.remove();
-        workManager.end();
+        unitOfWork.end();
       }
     }
 
@@ -91,7 +89,7 @@
       //close the em if necessary
       if (null != didWeStartWork.get() ) {
         didWeStartWork.remove();
-        workManager.end();
+        unitOfWork.end();
       }
     }
 
@@ -119,10 +117,11 @@
   }
 
   /**
+   * Returns True if rollback DID NOT HAPPEN (i.e. if commit should continue).
+   *
    * @param transactional The metadata annotaiton of the method
    * @param e The exception to test for rollback
    * @param txn A JPA Transaction to issue rollbacks on
-   * @return returns True if rollback DID NOT HAPPEN (i.e. if commit should continue).
    */
   private boolean rollbackIfNecessary(Transactional transactional, Exception e,
       EntityTransaction txn) {
diff --git a/extensions/persist/src/com/google/inject/persist/jpa/JpaPersistModule.java b/extensions/persist/src/com/google/inject/persist/jpa/JpaPersistModule.java
index 624bbaf..26da719 100644
--- a/extensions/persist/src/com/google/inject/persist/jpa/JpaPersistModule.java
+++ b/extensions/persist/src/com/google/inject/persist/jpa/JpaPersistModule.java
@@ -1,11 +1,27 @@
+/**
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package com.google.inject.persist.jpa;
 
 import com.google.inject.Singleton;
 import com.google.inject.internal.util.Preconditions;
 import com.google.inject.persist.PersistModule;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.PersistService;
+import com.google.inject.persist.UnitOfWork;
 import com.google.inject.util.Providers;
-import java.lang.annotation.Annotation;
 import java.util.Properties;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
@@ -13,55 +29,43 @@
 
 /**
  * JPA provider for guice persist.
+ *
+ * @author dhanji@gmail.com (Dhanji R. Prasanna)
  */
 public final class JpaPersistModule extends PersistModule {
   private final String jpaUnit;
 
   public JpaPersistModule(String jpaUnit) {
     Preconditions.checkArgument(null != jpaUnit && !jpaUnit.isEmpty(),
-        "Specified JPA unit name must be a non-empty string.");
+        "JPA unit name must be a non-empty string.");
     this.jpaUnit = jpaUnit;
   }
 
-  public JpaPersistModule(String jpaUnit, Class<? extends Annotation> unitOfWork) {
-    this(jpaUnit);
-    setUnitOfWork(unitOfWork);
-  }
-
-  public JpaPersistModule(String jpaUnit, Class<? extends Annotation> unitOfWork,
-      Class<? extends Annotation> transactional) {
-    this(jpaUnit);
-    setUnitOfWork(unitOfWork);
-    setTransactional(transactional);
-  }
-
   private Properties properties;
-  private final MethodInterceptor transactionInterceptor = new JpaLocalTxnInterceptor();
+  private MethodInterceptor transactionInterceptor;
 
   @Override protected void configurePersistence() {
-    bindConstant().annotatedWith(PersistModule.Persist.class).to(jpaUnit);
+    bindConstant().annotatedWith(Jpa.class).to(jpaUnit);
 
     if (null != properties) {
-      bind(Properties.class).annotatedWith(PersistModule.Persist.class).toInstance(properties);
+      bind(Properties.class).annotatedWith(Jpa.class).toInstance(properties);
     } else {
-      bind(Properties.class).annotatedWith(PersistModule.Persist.class)
+      bind(Properties.class).annotatedWith(Jpa.class)
           .toProvider(Providers.<Properties>of(null));
     }
 
-    bind(EntityManagerProvider.class).in(Singleton.class);
-    bind(EntityManagerProvider.EntityManagerFactoryProvider.class).in(Singleton.class);
+    bind(JpaPersistService.class).in(Singleton.class);
 
-    bind(EntityManager.class).toProvider(EntityManagerProvider.class);
+    bind(PersistService.class).to(JpaPersistService.class);
+    bind(UnitOfWork.class).to(JpaPersistService.class);
+    bind(EntityManager.class).toProvider(JpaPersistService.class);
     bind(EntityManagerFactory.class)
-        .toProvider(EntityManagerProvider.EntityManagerFactoryProvider.class);
+        .toProvider(JpaPersistService.EntityManagerFactoryProvider.class);
 
+    transactionInterceptor = new JpaLocalTxnInterceptor();
     requestInjection(transactionInterceptor);
   }
 
-  @Override protected Class<? extends WorkManager> getWorkManager() {
-    return EntityManagerProvider.class;
-  }
-
   @Override protected MethodInterceptor getTransactionInterceptor() {
     return transactionInterceptor;
   }
diff --git a/extensions/persist/src/com/google/inject/persist/jpa/EntityManagerProvider.java b/extensions/persist/src/com/google/inject/persist/jpa/JpaPersistService.java
similarity index 81%
rename from extensions/persist/src/com/google/inject/persist/jpa/EntityManagerProvider.java
rename to extensions/persist/src/com/google/inject/persist/jpa/JpaPersistService.java
index 7058d9a..cf52a9d 100644
--- a/extensions/persist/src/com/google/inject/persist/jpa/EntityManagerProvider.java
+++ b/extensions/persist/src/com/google/inject/persist/jpa/JpaPersistService.java
@@ -21,8 +21,8 @@
 import com.google.inject.Singleton;
 import com.google.inject.internal.Nullable;
 import com.google.inject.internal.util.Preconditions;
-import com.google.inject.persist.PersistModule;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.PersistService;
+import com.google.inject.persist.UnitOfWork;
 import java.util.Properties;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
@@ -32,15 +32,15 @@
  * @author Dhanji R. Prasanna (dhanji@gmail.com)
  */
 @Singleton
-class EntityManagerProvider implements Provider<EntityManager>, WorkManager {
+class JpaPersistService implements Provider<EntityManager>, UnitOfWork, PersistService {
   private final ThreadLocal<EntityManager> entityManager = new ThreadLocal<EntityManager>();
 
   private final String persistenceUnitName;
   private final Properties persistenceProperties;
 
   @Inject
-  public EntityManagerProvider(@PersistModule.Persist String persistenceUnitName,
-      @Nullable @PersistModule.Persist Properties persistenceProperties) {
+  public JpaPersistService(@Jpa String persistenceUnitName,
+      @Nullable @Jpa Properties persistenceProperties) {
     this.persistenceUnitName = persistenceUnitName;
     this.persistenceProperties = persistenceProperties;
   }
@@ -52,7 +52,7 @@
 
     EntityManager em = entityManager.get();
     Preconditions.checkState(null != em, "Requested EntityManager outside work unit. "
-        + "Try calling WorkManager.begin() first, or use a PersistenceFilter if you "
+        + "Try calling UnitOfWork.begin() first, or use a PersistFilter if you "
         + "are inside a servlet environment.");
 
     return em;
@@ -64,7 +64,7 @@
 
   public void begin() {
     Preconditions.checkState(null == entityManager.get(),
-        "Work already begun on this thread. Looks like you have called WorkManager.begin() twice"
+        "Work already begun on this thread. Looks like you have called UnitOfWork.begin() twice"
          + " without a balancing call to end() in between.");
 
     entityManager.set(emFactory.createEntityManager());
@@ -84,7 +84,7 @@
 
   private volatile EntityManagerFactory emFactory;
 
-  public synchronized void startPersistence() {
+  public synchronized void start() {
     Preconditions.checkState(null == emFactory, "Persistence service was already initialized.");
 
     if (null != persistenceProperties) {
@@ -95,17 +95,17 @@
     }
   }
 
-  public synchronized void shutdownPersistence() {
+  public synchronized void stop() {
     Preconditions.checkState(emFactory.isOpen(), "Persistence service was already shut down.");
     emFactory.close();
   }
 
   @Singleton
   public static class EntityManagerFactoryProvider implements Provider<EntityManagerFactory> {
-    private final EntityManagerProvider emProvider;
+    private final JpaPersistService emProvider;
 
     @Inject
-    public EntityManagerFactoryProvider(EntityManagerProvider emProvider) {
+    public EntityManagerFactoryProvider(JpaPersistService emProvider) {
       this.emProvider = emProvider;
     }
 
diff --git a/extensions/persist/src/com/google/inject/persist/jpa/package-info.java b/extensions/persist/src/com/google/inject/persist/jpa/package-info.java
index d452e0d..7a55893 100644
--- a/extensions/persist/src/com/google/inject/persist/jpa/package-info.java
+++ b/extensions/persist/src/com/google/inject/persist/jpa/package-info.java
@@ -1,4 +1,4 @@
 /**
- * guice Persist's Java Persistence API (JPA) support.
+ * guice-persist's Java Persistence API (JPA) support.
  */
 package com.google.inject.persist.jpa;
\ No newline at end of file
diff --git a/extensions/persist/src/com/google/inject/persist/package-info.java b/extensions/persist/src/com/google/inject/persist/package-info.java
index 8da2951..43cda2a 100644
--- a/extensions/persist/src/com/google/inject/persist/package-info.java
+++ b/extensions/persist/src/com/google/inject/persist/package-info.java
@@ -1,4 +1,4 @@
 /**
- * Guice Persist, a lightweight persistence library for Guice.
+ * Guice Persist: a lightweight persistence library for Guice.
  */
 package com.google.inject.persist;
\ No newline at end of file
diff --git a/extensions/persist/test/com/google/inject/persist/EdslTest.java b/extensions/persist/test/com/google/inject/persist/EdslTest.java
index 138dee8..b1d4b0e 100644
--- a/extensions/persist/test/com/google/inject/persist/EdslTest.java
+++ b/extensions/persist/test/com/google/inject/persist/EdslTest.java
@@ -10,7 +10,7 @@
  */
 public class EdslTest extends TestCase {
 
-  public void testModuleConfig() throws Exception {
+  public void testModuleConfigUsingJpa() throws Exception {
     new InjectorBuilder()
         .addModules(new JpaPersistModule("myunit"))
         .stage(Stage.PRODUCTION)
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/ClassLevelManagedLocalTransactionsTest.java b/extensions/persist/test/com/google/inject/persist/jpa/ClassLevelManagedLocalTransactionsTest.java
index aea192d..f66cdb3 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/ClassLevelManagedLocalTransactionsTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/ClassLevelManagedLocalTransactionsTest.java
@@ -19,8 +19,8 @@
 import com.google.inject.Guice;
 import com.google.inject.Inject;
 import com.google.inject.Injector;
+import com.google.inject.persist.PersistService;
 import com.google.inject.persist.Transactional;
-import com.google.inject.persist.WorkManager;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.Date;
@@ -47,11 +47,11 @@
     injector = Guice.createInjector(new JpaPersistModule("testUnit"));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
   }
 
   public void tearDown() {
-    injector.getInstance(WorkManager.class).shutdownPersistence();
+    injector.getInstance(PersistService.class).stop();
     injector = null;
   }
 
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/CustomPropsEntityManagerFactoryProvisionTest.java b/extensions/persist/test/com/google/inject/persist/jpa/CustomPropsEntityManagerFactoryProvisionTest.java
index cb97988..18f8932 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/CustomPropsEntityManagerFactoryProvisionTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/CustomPropsEntityManagerFactoryProvisionTest.java
@@ -18,7 +18,8 @@
 
 import com.google.inject.Guice;
 import com.google.inject.Injector;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.PersistService;
+import com.google.inject.persist.UnitOfWork;
 import java.util.Properties;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
@@ -40,18 +41,18 @@
 
   @Override
   public final void tearDown() {
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
     injector.getInstance(EntityManagerFactory.class).close();
   }
 
   public void testSessionCreateOnInjection() {
 
-    assertEquals("SINGLETON VIOLATION " + WorkManager.class.getName(),
-        injector.getInstance(WorkManager.class),
-        injector.getInstance(WorkManager.class));
+    assertEquals("SINGLETON VIOLATION " + UnitOfWork.class.getName(),
+        injector.getInstance(UnitOfWork.class),
+        injector.getInstance(UnitOfWork.class));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
 
     //obtain em
     assertTrue(injector.getInstance(EntityManager.class).isOpen());
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerFactoryProvisionTest.java b/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerFactoryProvisionTest.java
index d245cc3..3a6786e 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerFactoryProvisionTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerFactoryProvisionTest.java
@@ -18,7 +18,8 @@
 
 import com.google.inject.Guice;
 import com.google.inject.Injector;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.PersistService;
+import com.google.inject.persist.UnitOfWork;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
 import junit.framework.TestCase;
@@ -34,18 +35,18 @@
   }
 
   public final void tearDown() {
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
     injector.getInstance(EntityManagerFactory.class).close();
   }
 
   public void testSessionCreateOnInjection() {
 
-    assertTrue("SINGLETON VIOLATION " + WorkManager.class.getName(),
-        injector.getInstance(WorkManager.class)
-        .equals(injector.getInstance(WorkManager.class)));
+    assertTrue("SINGLETON VIOLATION " + UnitOfWork.class.getName(),
+        injector.getInstance(UnitOfWork.class)
+        .equals(injector.getInstance(UnitOfWork.class)));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
 
     //obtain em
     assertTrue(injector.getInstance(EntityManager.class).isOpen());
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerPerRequestProvisionTest.java b/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerPerRequestProvisionTest.java
index 4526b94..50c13da 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerPerRequestProvisionTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerPerRequestProvisionTest.java
@@ -19,8 +19,9 @@
 import com.google.inject.Guice;
 import com.google.inject.Inject;
 import com.google.inject.Injector;
+import com.google.inject.persist.PersistService;
 import com.google.inject.persist.Transactional;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.UnitOfWork;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
 import junit.framework.TestCase;
@@ -38,14 +39,14 @@
     injector = Guice.createInjector(new JpaPersistModule("testUnit"));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
 
-    injector.getInstance(WorkManager.class).begin();
+    injector.getInstance(UnitOfWork.class).begin();
   }
 
   @Override
   public final void tearDown() {
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
     injector.getInstance(EntityManagerFactory.class).close();
   }
 
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerProvisionTest.java b/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerProvisionTest.java
index 8cd7526..a477160 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerProvisionTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/EntityManagerProvisionTest.java
@@ -20,8 +20,8 @@
 import com.google.inject.Inject;
 import com.google.inject.Injector;
 import com.google.inject.Provider;
+import com.google.inject.persist.PersistService;
 import com.google.inject.persist.Transactional;
-import com.google.inject.persist.WorkManager;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
 import junit.framework.TestCase;
@@ -38,7 +38,7 @@
     injector = Guice.createInjector(new JpaPersistModule("testUnit"));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
   }
 
   public final void tearDown() {
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/JoiningLocalTransactionsTest.java b/extensions/persist/test/com/google/inject/persist/jpa/JoiningLocalTransactionsTest.java
index 54a6dba..74aba3b 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/JoiningLocalTransactionsTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/JoiningLocalTransactionsTest.java
@@ -19,8 +19,9 @@
 import com.google.inject.Guice;
 import com.google.inject.Inject;
 import com.google.inject.Injector;
+import com.google.inject.persist.PersistService;
 import com.google.inject.persist.Transactional;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.UnitOfWork;
 import java.io.IOException;
 import java.util.Date;
 import javax.persistence.EntityManager;
@@ -43,13 +44,13 @@
     injector = Guice.createInjector(new JpaPersistModule("testUnit"));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
   }
 
   //cleanup entitymanager in case some of the rollback tests left it in an open state
   @Override
   public final void tearDown() {
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
     injector.getInstance(EntityManagerFactory.class).close();
   }
 
@@ -64,7 +65,7 @@
     //test that the data has been stored
     Object result = em.createQuery("from JpaTestEntity where text = :text")
         .setParameter("text", UNIQUE_TEXT).getSingleResult();
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
 
     assertTrue("odd result returned fatal", result instanceof JpaTestEntity);
 
@@ -78,7 +79,7 @@
           .runOperationInTxnThrowingChecked();
     } catch (IOException e) {
       //ignore
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
     }
 
     EntityManager em = injector.getInstance(EntityManager.class);
@@ -90,7 +91,7 @@
     try {
       Object result = em.createQuery("from JpaTestEntity where text = :text")
           .setParameter("text", TRANSIENT_UNIQUE_TEXT).getSingleResult();
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
       fail("a result was returned! rollback sure didnt happen!!!");
     } catch (NoResultException e) { }
   }
@@ -101,7 +102,7 @@
           .runOperationInTxnThrowingUnchecked();
     } catch (RuntimeException re) {
       //ignore
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
     }
 
     EntityManager em = injector.getInstance(EntityManager.class);
@@ -111,7 +112,7 @@
     try {
       Object result = em.createQuery("from JpaTestEntity where text = :text")
           .setParameter("text", TRANSIENT_UNIQUE_TEXT).getSingleResult();
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
       fail("a result was returned! rollback sure didnt happen!!!");
     } catch (NoResultException e) {}
   }
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/JpaWorkManagerTest.java b/extensions/persist/test/com/google/inject/persist/jpa/JpaWorkManagerTest.java
index c68a422..13049d6 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/JpaWorkManagerTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/JpaWorkManagerTest.java
@@ -19,8 +19,9 @@
 import com.google.inject.Guice;
 import com.google.inject.Inject;
 import com.google.inject.Injector;
+import com.google.inject.persist.PersistService;
 import com.google.inject.persist.Transactional;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.UnitOfWork;
 import java.util.Date;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
@@ -40,7 +41,7 @@
     injector = Guice.createInjector(new JpaPersistModule("testUnit"));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
   }
 
   @Override
@@ -49,15 +50,15 @@
   }
 
   public void testWorkManagerInSession() {
-    injector.getInstance(WorkManager.class).begin();
+    injector.getInstance(UnitOfWork.class).begin();
     try {
       injector.getInstance(TransactionalObject.class).runOperationInTxn();
     } finally {
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
 
     }
 
-    injector.getInstance(WorkManager.class).begin();
+    injector.getInstance(UnitOfWork.class).begin();
     injector.getInstance(EntityManager.class).getTransaction().begin();
     try {
       final Query query = injector.getInstance(EntityManager.class)
@@ -75,15 +76,15 @@
 
     } finally {
       injector.getInstance(EntityManager.class).getTransaction().commit();
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
     }
   }
 
   public void testCloseMoreThanOnce() {
-    injector.getInstance(WorkManager.class).shutdownPersistence();
+    injector.getInstance(PersistService.class).stop();
 
     try {
-      injector.getInstance(WorkManager.class).shutdownPersistence();
+      injector.getInstance(PersistService.class).stop();
       fail();
     } catch (IllegalStateException e) {
       // Ignored.
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/ManagedLocalTransactionsAcrossRequestTest.java b/extensions/persist/test/com/google/inject/persist/jpa/ManagedLocalTransactionsAcrossRequestTest.java
index cc9a3fd..3934d3b 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/ManagedLocalTransactionsAcrossRequestTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/ManagedLocalTransactionsAcrossRequestTest.java
@@ -20,8 +20,9 @@
 import com.google.inject.Inject;
 import com.google.inject.Injector;
 import com.google.inject.name.Named;
+import com.google.inject.persist.PersistService;
 import com.google.inject.persist.Transactional;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.UnitOfWork;
 import com.google.inject.persist.finder.Finder;
 import java.io.IOException;
 import java.util.Date;
@@ -46,7 +47,7 @@
     injector = Guice.createInjector(new JpaPersistModule("testUnit"));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
   }
 
   @Override
@@ -63,13 +64,13 @@
     //test that the data has been stored
     Object result = em.createQuery("from JpaTestEntity where text = :text")
         .setParameter("text", UNIQUE_TEXT).getSingleResult();
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
 
     assertTrue("odd result returned fatal", result instanceof JpaTestEntity);
 
     assertEquals("queried entity did not match--did automatic txn fail?",
         UNIQUE_TEXT, ((JpaTestEntity) result).getText());
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
 
   }
 
@@ -90,13 +91,13 @@
 
     Object result = em.createQuery("from JpaTestEntity where text = :text")
         .setParameter("text", UNIQUE_TEXT_MERGE).getSingleResult();
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
 
     assertTrue(result instanceof JpaTestEntity);
 
     assertEquals("queried entity did not match--did automatic txn fail?",
         UNIQUE_TEXT_MERGE, ((JpaTestEntity) result).getText());
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
 
   }
 
@@ -114,14 +115,14 @@
     assertTrue("Merge did not store state or did not return persistent copy", em.contains(entity));
 
     Object result = injector.getInstance(TransactionalObject.class).find(UNIQUE_TEXT_MERGE_FORDF);
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
 
     assertNotNull(result);
     assertTrue(result instanceof JpaTestEntity);
 
     assertEquals("queried entity did not match--did automatic txn fail?",
         UNIQUE_TEXT_MERGE_FORDF, ((JpaTestEntity) result).getText());
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
 
   }
 
@@ -130,7 +131,7 @@
       injector.getInstance(TransactionalObject.class).runOperationInTxnThrowingChecked();
     } catch (IOException e) {
       //ignore
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
     }
 
     EntityManager em = injector.getInstance(EntityManager.class);
@@ -142,11 +143,11 @@
     try {
       Object result = em.createQuery("from JpaTestEntity where text = :text")
           .setParameter("text", TRANSIENT_UNIQUE_TEXT).getSingleResult();
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
       fail();
     } catch (NoResultException e) {}
 
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
   }
 
   public void testSimpleTransactionRollbackOnUnchecked() {
@@ -154,7 +155,7 @@
       injector.getInstance(TransactionalObject.class).runOperationInTxnThrowingUnchecked();
     } catch (RuntimeException re) {
       //ignore
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
     }
 
     EntityManager em = injector.getInstance(EntityManager.class);
@@ -164,11 +165,11 @@
     try {
       Object result = em.createQuery("from JpaTestEntity where text = :text")
           .setParameter("text", TRANSIENT_UNIQUE_TEXT).getSingleResult();
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
       fail();
     } catch (NoResultException e) {}
     
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
   }
 
   public static class TransactionalObject {
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/ManagedLocalTransactionsTest.java b/extensions/persist/test/com/google/inject/persist/jpa/ManagedLocalTransactionsTest.java
index 2432015..9707dd1 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/ManagedLocalTransactionsTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/ManagedLocalTransactionsTest.java
@@ -19,8 +19,9 @@
 import com.google.inject.Guice;
 import com.google.inject.Inject;
 import com.google.inject.Injector;
+import com.google.inject.persist.PersistService;
 import com.google.inject.persist.Transactional;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.UnitOfWork;
 import java.io.IOException;
 import java.util.Date;
 import javax.persistence.EntityManager;
@@ -42,12 +43,12 @@
     injector = Guice.createInjector(new JpaPersistModule("testUnit"));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
   }
 
   @Override
   public final void tearDown() {
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
     injector.getInstance(EntityManagerFactory.class).close();
   }
 
@@ -60,7 +61,7 @@
     //test that the data has been stored
     Object result = em.createQuery("from JpaTestEntity where text = :text")
         .setParameter("text", UNIQUE_TEXT).getSingleResult();
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
 
     assertTrue("odd result returned fatal", result instanceof JpaTestEntity);
 
@@ -80,7 +81,7 @@
 
     Object result = em.createQuery("from JpaTestEntity where text = :text")
         .setParameter("text", UNIQUE_TEXT_MERGE).getSingleResult();
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
 
     assertTrue(result instanceof JpaTestEntity);
 
@@ -93,7 +94,7 @@
       injector.getInstance(TransactionalObject.class).runOperationInTxnThrowingChecked();
     } catch (IOException e) {
       //ignore
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
     }
 
     EntityManager em = injector.getInstance(EntityManager.class);
@@ -105,7 +106,7 @@
     try {
       Object result = em.createQuery("from JpaTestEntity where text = :text")
           .setParameter("text", TRANSIENT_UNIQUE_TEXT).getSingleResult();
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
       fail("a result was returned! rollback sure didnt happen!!!");
     } catch (NoResultException e) {}
   }
@@ -115,7 +116,7 @@
       injector.getInstance(TransactionalObject.class).runOperationInTxnThrowingUnchecked();
     } catch (RuntimeException re) {
       //ignore
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
     }
 
     EntityManager em = injector.getInstance(EntityManager.class);
@@ -125,7 +126,7 @@
     try {
       Object result = em.createQuery("from JpaTestEntity where text = :text")
           .setParameter("text", TRANSIENT_UNIQUE_TEXT).getSingleResult();
-      injector.getInstance(WorkManager.class).end();
+      injector.getInstance(UnitOfWork.class).end();
       fail("a result was returned! rollback sure didnt happen!!!");
     } catch (NoResultException e) {}
   }
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsConfidenceTest.java b/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsConfidenceTest.java
index fdbe48a..c0a8f80 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsConfidenceTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsConfidenceTest.java
@@ -19,8 +19,8 @@
 import com.google.inject.Guice;
 import com.google.inject.Inject;
 import com.google.inject.Injector;
+import com.google.inject.persist.PersistService;
 import com.google.inject.persist.Transactional;
-import com.google.inject.persist.WorkManager;
 import java.util.Date;
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceException;
@@ -40,12 +40,12 @@
     injector = Guice.createInjector(new JpaPersistModule("testUnit"));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
   }
 
   @Override
   public final void tearDown() {
-    injector.getInstance(WorkManager.class).shutdownPersistence();
+    injector.getInstance(PersistService.class).stop();
   }
 
   public void testThrowingCleanupInterceptorConfidence() {
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsTest.java b/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsTest.java
index 7a0534b..8034076 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsTest.java
@@ -19,8 +19,9 @@
 import com.google.inject.Guice;
 import com.google.inject.Inject;
 import com.google.inject.Injector;
+import com.google.inject.persist.PersistService;
 import com.google.inject.persist.Transactional;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.UnitOfWork;
 import java.util.Date;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
@@ -41,7 +42,7 @@
     injector = Guice.createInjector(new JpaPersistModule("testUnit"));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
   }
 
   public void tearDown() {
@@ -49,7 +50,7 @@
   }
 
   public void testSimpleCrossTxnWork() {
-    injector.getInstance(WorkManager.class).begin();
+    injector.getInstance(UnitOfWork.class).begin();
 
     //pretend that the request was started here
     EntityManager em = injector.getInstance(EntityManager.class);
@@ -63,8 +64,8 @@
     assertTrue("EntityManager  appears to have been closed across txns!", em.contains(entity));
     assertTrue("EntityManager appears to have been closed across txns!", em.isOpen());
 
-    injector.getInstance(WorkManager.class).end();
-    injector.getInstance(WorkManager.class).begin();
+    injector.getInstance(UnitOfWork.class).end();
+    injector.getInstance(UnitOfWork.class).begin();
 
     //try to query them back out
     em = injector.getInstance(EntityManager.class);
diff --git a/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsWithCustomMatcherTest.java b/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsWithCustomMatcherTest.java
index d20a871..7fedb86 100644
--- a/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsWithCustomMatcherTest.java
+++ b/extensions/persist/test/com/google/inject/persist/jpa/ManualLocalTransactionsWithCustomMatcherTest.java
@@ -19,8 +19,9 @@
 import com.google.inject.Guice;
 import com.google.inject.Inject;
 import com.google.inject.Injector;
+import com.google.inject.persist.PersistService;
 import com.google.inject.persist.Transactional;
-import com.google.inject.persist.WorkManager;
+import com.google.inject.persist.UnitOfWork;
 import java.util.Date;
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
@@ -45,7 +46,7 @@
     injector = Guice.createInjector(new JpaPersistModule("testUnit"));
 
     //startup persistence
-    injector.getInstance(WorkManager.class).startPersistence();
+    injector.getInstance(PersistService.class).start();
   }
 
   @Override
@@ -69,7 +70,7 @@
     assertTrue("EntityManager  appears to have been closed across txns!", em.contains(entity));
     assertTrue("EntityManager appears to have been closed across txns!", em.isOpen());
 
-    injector.getInstance(WorkManager.class).end();
+    injector.getInstance(UnitOfWork.class).end();
 
     //try to query them back out
     em = injector.getInstance(EntityManager.class);