diff --git a/source/documentation/fuseki2/__index.md b/source/documentation/fuseki2/__index.md
index 447a77f..5a6d4d8 100644
--- a/source/documentation/fuseki2/__index.md
+++ b/source/documentation/fuseki2/__index.md
@@ -5,36 +5,39 @@
 
 Apache Jena Fuseki is a SPARQL server.  It can run as a operating system
 service, as a Java web application (WAR file), and as a standalone server.
-It provides security (using [Apache Shiro](https://shiro.apache.org/)) and
-has a user interface for server monitoring and administration.
 
-It provides the SPARQL 1.1
-[protocols for query and update](http://www.w3.org/TR/sparql11-protocol/)
+Fuseki comes in in two forms, a single system "webapp", combined with a UI
+for admin and query, and as "main", a server suitable to run as part of a larger
+deployment, including [with Docker](fuseki-main.html#docker) or running embedded.
+Both forms use the same core protocol engine and [same configuration file
+format](fuseki-configuration.html).
+
+Fuseki provides the
+SPARQL 1.1 [protocols for query and update](http://www.w3.org/TR/sparql11-protocol/)
 as well as the
 [SPARQL Graph Store protocol](http://www.w3.org/TR/sparql11-http-rdf-update/).
 
 Fuseki is tightly integrated with [TDB](../tdb/index.html) to provide a robust,
 transactional persistent storage layer, and incorporates
 [Jena text query](../query/text-query.html).
-It can be used to provide the protocol engine for other RDF query and
-storage systems.
 
 ## Contents
 
-- [Download](#download-fuseki)
+- [Download with UI](#download-fuseki)
 - [Getting Started](#getting-started-with-fuseki)
-- [Security](fuseki-security.html)
-- [Running Fuseki](fuseki-run.html)
-    - [As a standalone server with UI](fuseki-run.html#fuseki-standalone-server)
-    - [As a service](fuseki-run.html#fuseki-service)
-    - [As a web application](fuseki-run.html#fuseki-web-application)
-    - [As an standalone SPARQL server](fuseki-main.html)
-    - [As an embedded SPARQL server](fuseki-main.html)
-- Architecture
-    - [Server URI scheme : services and datasets](fuseki-data-services.html)
-    - [Server Admin Protocol](fuseki-server-protocol.html)
+- [Running Fuseki with UI](fuseki-webapp.html)
+    - [As a standalone server with UI](fuseki-webapp.html#fuseki-standalone-server)
+    - [As a service](fuseki-webapp.html#fuseki-service)
+    - [As a web application](fuseki-webapp.html#fuseki-web-application)
+    - [Security](fuseki-security.html) with [Apache Shiro](https://shiro.apache.org/)
+- [Running Fuseki Server](fuseki-main.html)
+    - [Setup](fuseki-main.html#setup)
+    - [As a Docker container](fuseki-main#fuseki-docker)
+    - [As an embedded SPARQL server](fuseki-embedded.html)
+    - [Security and data access control](fuseki-data-access-control.html)
 - [Fuseki Configuration](fuseki-configuration.html)
 - [Logging](fuseki-logging.html)
+- [Server Statistics and Metrics](fuseki-server-info.html)
 - [How to Contribute](#how-to-contribute)
 - Client access
     - [Use from Java](../rdfconnection)
@@ -45,7 +48,7 @@
 
 [Email support lists](/help_and_support/#email-support-lists)
 
-## Download Fuseki
+## Download Fuseki with UI
 
 Releases of Apache Jena Fuseki can be downloaded from one of the mirror sites:
 
@@ -57,20 +60,14 @@
 
 **Fuseki download files**
 
-Filename | Description
---------- | -----------
-`fuseki-*VER*.distribution.zip` | Fuseki download, includes everything.
-`fuseki-*VER*-server.jar`  | Fuseki server, as an executable jar.
-`fuseki-*VER*-server.war`  | Fuseki server, as a web application archive (.war) file.
+| Filename | Description |
+|---------|-------------|
+|`apache-jena-fuseki-*VER*.zip` | Fuseki with UI download |
+|`[jena-fuseki-server](https://repo1.maven.org/maven2/org/apache/jena/jena-fuseki-server) | The Fuseki Main packaging |
 
-    <dependency>
-       <groupId>org.apache.jena</groupId>
-       <artifactId>jena-fuseki-war</artifactId>
-       <type>war</type>
-       <version>X.Y.Z</version>
-    </dependency>
+`apache-jena-fuseki-*VER*.zip` contains both a war file and an executable jar.
 
-and for [Fuseki Main](fuseki-main):
+Fuskei Main is also available as a Maven artifact:
 
     <dependency>
        <groupId>org.apache.jena</groupId>
@@ -99,7 +96,7 @@
 The [quick start](fuseki-quick-start.html) section serves as a basic
 guide to getting a Fuseki server running on your local machine.  
 
-See [all the ways to run Fuseki](fuseki-run.html) for complete coverage of all the
+See [all the ways to run Fuseki](fuseki-webapp.html) for complete coverage of all the
 deployment methods for Fuseki.
 
 ## How to Contribute
@@ -119,5 +116,5 @@
 Development builds (not a formal release):
 [SNAPSHOT](https://repository.apache.org/content/repositories/snapshots/org/apache/jena/jena-fuseki/)
 
-Source code mirrored to github:
+Source code:
 [https://github.com/apache/jena/tree/master/jena-fuseki2](https://github.com/apache/jena/tree/master/jena-fuseki2)
diff --git a/source/documentation/fuseki2/fuseki-config-endpoint.md b/source/documentation/fuseki2/fuseki-config-endpoint.md
index 45512a2..3813a6c 100644
--- a/source/documentation/fuseki2/fuseki-config-endpoint.md
+++ b/source/documentation/fuseki2/fuseki-config-endpoint.md
@@ -1,17 +1,10 @@
 ---
-title: Fuseki Configuration - New Syntax
+title: Fuseki Data Service Configuration Syntax
 ---
 
-Apache Jena 3.13.0 introduces a new syntax for the facilities of a Fuseki service.
-
-The [previous syntax](fuseki-configuration.html) is still valid.
-
-The new syntax enables more configuration options:
-
-* setting the context on a per-endpoint basis
-* having multiple operations at the service access point, switching based on
-operation type
-* a more general structure for adding custom services
+A data service provides a number of operations on a dataset. These can be
+explicitly named endpoints or operations at the URL of the dataset.  New
+operations can be configured in; these typically have their own named endpoints.
 
 ## Syntax
 
@@ -35,16 +28,13 @@
         ja:data "data.trig" .
 
 This is invoked with a URL of the form
-<tt>http://<i>host:port</i>/dataset?query=...</tt>
-which is a SPARQl query request sent to the dataset URL.
-
-The new syntax is the `fuseki:endpoint`.
+<tt>http://<i>host:port</i>/dataset?query=.\..</tt>
+which is a SPARQL query request sent to the dataset URL.
 
 The property `fuseki:endpoint` describes the operation available. No name is
 given so the operation is available at the URL of the dataset.
 
-`fuseki:dataset` names the dataset to be used with this data service. The syntax
-and options are unchanged from the [previous syntax](fuseki-configuration.html).
+`fuseki:dataset` names the dataset to be used with this data service.
 
 In this second example:
 
@@ -58,7 +48,7 @@
 
 the endpoint has a name. The URL to invoke the operation is now:
 
-<tt>http://<i>host:port</i>/dataset/sparql?query=...</tt>
+<tt>http://<i>host:port</i>/dataset/sparql?query=.\..</tt>
 
 and is similar to older form:
 
@@ -78,40 +68,24 @@
         ] ;
         fuseki:dataset      <#dataset> .
 
+### Original Configuration Syntax
 
-The standard set of service installed by running the server from the command line
-without a configuration file is:
+The syntax described on this page was introduced in Apache Jena 3.13.0.
 
-    <#service1> rdf:type fuseki:Service ;
-        fuseki:name "dataset" ;
-        fuseki:endpoint [ 
-            fuseki:operation fuseki:query ;
-            fuseki:name "sparql" 
-        ];
-        fuseki:endpoint [
-            fuseki:operation fuseki:query ;
-            fuseki:name "query" 
-        ] ;
-        fuseki:endpoint [
-            fuseki:operation fuseki:update ;
-            fuseki:name      "update"
-        ] ;
-        fuseki:endpoint [
-            fuseki:operation fuseki:gsp-r ;
-            fuseki:name "get"
-        ] ;
-        fuseki:endpoint [ 
-            fuseki:operation fuseki:gsp-rw ; 
-            fuseki:name "data"
-        ] ; 
-        fuseki:endpoint [ 
-            fuseki:operation fuseki:upload ;
-            fuseki:name "upload"
-        ] ; 
-        fuseki:dataset ...
+The [previous syntax](fuseki-old-config-endpoint.html) is still valid.
+
+The new syntax enables more configuration options and gives more control of server functionality:
+
+* setting the context on a per-endpoint basis
+* having multiple operations at the service access point, switching based on
+operation type
+* a more general structure for adding custom services
+* adding custom extensions to a Fuseki server
 
 ## Operations
 
+The following operations are provided:
+
 | URI | Operation |
 |-----|-----------|
 | `fuseki:query`  | SPARQL 1.1 Query with ARQ extensions |
@@ -121,6 +95,61 @@
 | `fuseki:upload` | HTML form file upload |
 | `fuseki:no-op`  | An operation that causes a 400 or 404 error |
 
+Custom extensions can be added (see [Programmatic configuration](fuseki-main.html#build) of the Fuseki server). To be able to uniquely identify the operation, these are usually 
+
+        fuseki:endpoint     [ 
+            fuseki:operation fuseki:shacl ;
+            fuseki:name      "shacl" ;
+        ] ;
+
+See the section ["Integration with Apache Jena Fuseki"](/documentation/shacl/#integration-with-apache-jena-fuseki) for details of the SHACL support. While this operation is part of the standard Fuseki distribution, this operation is added during system initialization, using the custom operation support.
+
+### Command Line Equivalents
+
+The standard set of service installed by running the server from the command line
+without a configuration file is for a read-only:
+
+    <#service1> rdf:type fuseki:Service ;
+        fuseki:name "dataset" ;
+        fuseki:endpoint [ fuseki:operation fuseki:query ; ];
+        fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "sparql" ];
+        fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "query" ];
+
+        fuseki:endpoint [ fuseki:operation fuseki:gsp-r ; ];
+        fuseki:endpoint [ fuseki:operation fuseki:gsp-r ; fuseki:name "get" ];
+        fuseki:dataset ...
+
+which supports requests such as:
+
+    http://<i>host:port</i>/dataset?query=...
+    
+    http://<i>host:port</i>/dataset/sparql?query=...
+    
+    http://<i>host:port</i>/dataset?default
+    
+    http://<i>host:port</i>/dataset/get?default
+
+and for an updatable dataset (command line `--mem` for an in-memory dataset;
+or with TDB storage, with `--update`):
+
+    <#service1> rdf:type fuseki:Service ;
+        fuseki:name "dataset" ;
+        fuseki:endpoint [ fuseki:operation fuseki:query ;];
+        fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "sparql" ];
+        fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "query" ];
+
+        fuseki:endpoint [ fuseki:operation fuseki:update ; ];
+        fuseki:endpoint [ fuseki:operation fuseki:update ; fuseki:name "update" ];
+
+        fuseki:endpoint [ fuseki:operation fuseki:gsp-r ; fuseki:name "get" ];
+        fuseki:endpoint [ fuseki:operation fuseki:gsp-rw ; ] ;
+        fuseki:endpoint [ fuseki:operation fuseki:gsp-rw ; fuseki:name "data" ];
+        fuseki:endpoint [ fuseki:operation fuseki:upload ; fuseki:name "upload" ]
+        fuseki:dataset ...
+
+which adds requests that can change the data.
+
+
 New operations can be added by programmatic setup in [Fuseki Main](/documentation/fuseki2/fuseki-main).
 
 ## Dispatch
@@ -152,7 +181,7 @@
 
 Custom services usually use a named endpoint.  Custom operations
 can specific a content type that they handle, which must be unique for the
-operation, and they can not provide a query string signature for dispatch.
+operation. They can not provide a query string signature for dispatch.
 
 ## Common Cases
 
@@ -173,7 +202,7 @@
 
 #### Case 2: Dataset level operation.
 
-The 3 SPARQL standard operations for a read-write dataset:
+The 3 SPARQL standard operations for a read-write dataset, request are sent to <tt>http://<i>host:port</i>/dataset</tt>. There are no named endpoint services.
 
     <#service> rdf:type fuseki:Service ;
         fuseki:name     "ds-rw" ;
@@ -198,6 +227,23 @@
 The operation on this dataset can only be accessed as "/ds-named/sparql",
 "/ds-named/update" etc, not as "/ds-named".
 
+#### Case 4: Named endpoints with query of the dataset.
+
+    <#service1> rdf:type fuseki:Service ;
+        
+        fuseki:name     "ds" ;
+        fuseki:endpoint [ fuseki:operation fuseki:query ] ;
+        fuseki:endpoint [ fuseki:operation fuseki:query;  fuseki:name "sparql"  ] ;
+        fuseki:endpoint [ fuseki:operation fuseki:query;  fuseki:name "query"   ] ;
+        fuseki:endpoint [ fuseki:operation fuseki:update; fuseki:name "update"  ] ;
+        fuseki:endpoint [ fuseki:operation fuseki:upload; fuseki:name "upload"  ] ;
+        fuseki:endpoint [ fuseki:operation fuseki:gsp_r;  fuseki:name "get"     ] ;
+        fuseki:endpoint [ fuseki:operation fuseki:gsp_rw; fuseki:name "data"    ] ;
+        fuseki:dataset  <#dataset> .
+
+The operations on this dataset are accessed as "/ds/sparql",
+"/ds/update" etc. In addition, "/ds?query=" provided SPARQL query.
+
 ## Quad extensions
 
 The GSP (SPARQL Graph Store Protocol) operations provide the HTTP operations of 
@@ -213,7 +259,8 @@
 
 Fuseki also provides [/documentation/io/rdf-binary.html](RDF Binary) for triples and quads.
 
-The quads extension applies when there is no `?default` or `?graph`.
+The quads extension applies when there is no `?default` or `?graph`. 
+`GET` fetches the dataset in quads format, and `PUT` and `POST` take quads format data (N-Quads and Trig).
 
 ## Context
 
@@ -253,7 +300,7 @@
 
 ## Security
 
-The page [Data Access Control for Fuseki](/documentation/fuseki2/data-access-control)
+The page [Data Access Control for Fuseki](./fuseki-data-access-control.html)
 covers the 
 
 For endpoints, the permitted users are part of the endpoint description.
@@ -263,12 +310,3 @@
         fuseki:name "sparql" ;
         fuseki:allowedUsers "user1", "user2"
     ] ;
-
-## Legacy Behaviour
-
-For compatibility with the older configuration behaviour, the Fuseki dispatch
-code includes an additional dispatch option.
-
-If a request is made on the dataset (no service name in the request URL), then
-the dispatcher classifies the operation and looks for a named endpoint for that
-operation of any name. If one is found, that is used.
diff --git a/source/documentation/fuseki2/fuseki-configuration.md b/source/documentation/fuseki2/fuseki-configuration.md
index 38fed78..c973c82 100644
--- a/source/documentation/fuseki2/fuseki-configuration.md
+++ b/source/documentation/fuseki2/fuseki-configuration.md
@@ -2,22 +2,38 @@
 title: "Fuseki: Configuring Fuseki"
 ---
 
-Configuration consists of defining the data services (data and actions available on the data) together with configuring the server.  Explicitly configuring the server is often unnecessary.
+A Fuseki server is configured by defining the data services (data and actions available on the data). There is also server configuration although this is often unnecessary.
 
 The data services configuration can come from:
 
+For Fuseki Full (webapp with UI):
+
 1. The directory `FUSEKI_BASE/configuration/` with one data service assembler per file (includes endpoint details and the dataset description.)
 2. The system database. This includes uploaded assembler files.  It also keeps the state of each data service (whether it's active or offline).
-3. The service configuration file.  For compatibility, the service configuration file can also have data services. [See below](#relationship-to-fuseki-1-configuration).
+3. The server configuration file `config.ttl`.  For compatibility, the server configuration file can also have data services.
 4. The command line, if not running as a web application from a .war file.
 
 `FUSEKI_BASE` is the location of the [Fuseki run area](./fuseki-layout.html).
 
-## Data Service assembler
+For [Fuseki Main](fuseki-main.html):
 
-See [Fuseki Data Services](fuseki-data-services.html) for the architecture of data services.
+1. The command line, using `--conf` to provide a configuration file.
+2. The command line, using arguments (e.g. `--mem /ds` or `--tdb2 --loc DB2 /ds`).
+3. [Programmatic configuration](fuseki-main.html#build) of the server.
 
-See [Fuseki Security](fuseki-security.html) for more information on security.
+See [Fuseki Security](fuseki-security.html) for more information on security configuration.
+
+## Examples
+
+Example server configuration files can be found at [jena-fuseki2/examples](https://github.com/apache/jena/tree/master/jena-fuseki2/examples).
+
+## Security and Access Control
+
+Access Control can be configured on any of the server, data service or dataset.
+[Fuseki Data Access Control](fuseki-data-access-control.html).
+
+Separately, Fuseki Full has request based security filtering provided by Apache Shiro:
+[Fuseki Full Security](fuseki-security.html)
 
 ## Fuseki Configuration File
 
@@ -37,12 +53,13 @@
 
 Some useful prefix declarations:
 
-    @prefix fuseki:  <http://jena.apache.org/fuseki#> .
-    @prefix rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
-    @prefix rdfs:    <http://www.w3.org/2000/01/rdf-schema#> .
-    @prefix tdb:     <http://jena.hpl.hp.com/2008/tdb#> .
-    @prefix ja:      <http://jena.hpl.hp.com/2005/11/Assembler#> .
-    @prefix :        <#> .
+    PREFIX fuseki:  <http://jena.apache.org/fuseki#>
+    PREFIX rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+    PREFIX rdfs:    <http://www.w3.org/2000/01/rdf-schema#>
+    PREFIX tdb1:    <http://jena.hpl.hp.com/2008/tdb#>
+    PREFIX tdb2:    <http://jena.apache.org/2016/tdb#>
+    PREFIX ja:      <http://jena.hpl.hp.com/2005/11/Assembler#>
+    PREFIX :        <#>
 
 ### Assembler Initialization
 
@@ -62,46 +79,126 @@
 This example offers SPARQL Query, SPARQL Update and SPARQL Graph
 Store protocol, as well as file upload.
 
-Note: As of Jena 3.13.0, 
-[an additional, more expressive configuration for endpoints](fuseki-config-endpoint.html)
-is available.
+See [Data Service Configuration Syntax](fuseki-config-endpoint.html) for the complete details of the endpoint configuration description. Here, we show some examples.
+
+The [original configuration](fuseki-old-config-endpoint.html) syntax, using, for example, `fuseki:serviceQuery`, is still supported.
 
 The base name is `/ds`.
 
-    ## Updateable in-memory dataset.
+    ## Updatable in-memory dataset.
 
     <#service1> rdf:type fuseki:Service ;
-        fuseki:name                       "ds" ;       # http://host:port/ds
-        fuseki:serviceQuery               "sparql" ;   # SPARQL query service
-        fuseki:serviceQuery               "query" ;    # SPARQL query service (alt name)
-        fuseki:serviceUpdate              "update" ;   # SPARQL update service
-        fuseki:serviceUpload              "upload" ;   # Non-SPARQL upload service
-        fuseki:serviceReadWriteGraphStore "data" ;     # SPARQL Graph store protocol (read and write)
-        # A separate read-only graph store endpoint:
-        fuseki:serviceReadGraphStore      "get" ;      # SPARQL Graph store protocol (read only)
-        fuseki:dataset                   <#dataset> ;
+        fuseki:name   "ds" ;       # http://host:port/ds
+        fuseki:endpoint [ 
+             # SPARQL query service
+            fuseki:operation fuseki:query ; 
+            fuseki:name "sparql"
+        ] ;
+        fuseki:endpoint [ 
+             # SPARQL query service (alt name)
+            fuseki:operation fuseki:query ; 
+            fuseki:name "query" 
+        ] ;
+
+        fuseki:endpoint [ 
+             # SPARQL update service
+            fuseki:operation fuseki:update ; 
+            fuseki:name "update" 
+        ] ;
+
+        fuseki:endpoint [ 
+             # HTML file upload service
+            fuseki:operation fuseki:update ; 
+            fuseki:name "update" 
+        ] ;
+
+        fuseki:endpoint [ 
+             # SPARQL Graph Store Protocol (read)
+            fuseki:operation fuseki:gsp_r ; 
+            fuseki:name "get" 
+        ] ;
+        fuseki:endpoint [ 
+            # SPARQL Graph Store Protcol (read and write)
+            fuseki:operation fuseki:gsp_rw ; 
+            fuseki:name "data" 
+        ] ;
+
+        fuseki:dataset  <#dataset> ;
         .
 
 `<#dataset>` refers to a dataset description in the same file.
 
+HTTP requests will include the service name: <tt>http://<i>host:port</i>/ds/sparql?query=.\..</tt>.
+
 ### Read-only service
 
 This example offers only read-only endpoints (SPARQL Query and HTTP GET
-SPARQl Graph Store protocol).
+SPARQL Graph Store protocol).
 
 This service offers read-only access to a dataset with a single
 graph of data.
 
     <#service2> rdf:type fuseki:Service ;
-        fuseki:name                     "/ds-ro" ;   # http://host:port/ds-ro
-        fuseki:serviceQuery             "query" ;    # SPARQL query service
-        fuseki:serviceReadGraphStore    "data" ;     # SPARQL Graph store protocol (read only)
+        fuseki:name      "/ds-ro" ;   # http://host:port/ds-ro
+        fuseki:endpoint  [ fuseki:operation fuseki:query ; fuseki:name "sparql" ];
+        fuseki:endpoint  [ fuseki:operation fuseki:query ; fuseki:name "query" ];
+        fuseki:endpoint  [ fuseki:operation fuseki:gsp_r ; fuseki:name "data" ];
         fuseki:dataset           <#dataset> ;
         .
 
-### Dataset
+### Data services on the dataset
 
-#### In-memory
+The standard SPARQL operations can also be defined on the dataset URL with no secondary service name:
+
+<#service2> rdf:type fuseki:Service ;
+        fuseki:name     "/dataset" ;
+        fuseki:endpoint  [ fuseki:operation fuseki:query ];
+        fuseki:endpoint  [ fuseki:operation fuseki:gsp_r ];
+        fuseki:dataset  <#dataset> ;
+        .
+
+HTTP requests use the URL of the dataset.
+
+* SPARQL Query: <tt>http://<i>host:port</i>/dataset?query=.\..</tt>
+* Fetch the default graph 
+([SPARQL Graph Store Protocol](https://www.w3.org/TR/sparql11-http-rdf-update/)):
+<tt>http://<i>host:port</i>/dataset?default</tt>
+
+## Server Configuration
+
+If you need to load additional classes, or set global parameters, then these go in
+`FUSEKI_BASE/config.ttl`.
+
+Additional classes can not be loaded if running as a `.war` file.  You will
+need to create a custom `.war` file consisting of the contents of the Fuseki
+web application and the additional classes
+
+The server section is optional.
+
+If absent, fuseki configuration is performed
+by searching the configuration file for the type `fuseki:Service`.
+
+### Server Section
+
+    [] rdf:type fuseki:Server ;
+       # Server-wide context parameters can be given here.
+       # For example, to set query timeouts: on a server-wide basis:
+       # Format 1: "1000" -- 1 second timeout
+       # Format 2: "10000,60000" -- 10s timeout to first result, then 60s timeout to for rest of query.
+       # See java doc for ARQ.queryTimeout
+       # ja:context [ ja:cxtName "arq:queryTimeout" ;  ja:cxtValue "10000" ] ;
+
+       # Load custom code (rarely needed)
+       # ja:loadClass "your.code.Class" ;
+
+       # Explicitly choose which services to add to the server.
+       # If absent, include all descriptions of type `fuseki:Service`.
+       # fuseki:services (<#service1> <#service2>)
+       .
+
+## Datasets
+
+### In-memory
 
 An in-memory dataset, with data in the default graph taken from a local file.
 
@@ -114,7 +211,7 @@
           ] ;
         .
 
-#### TDB
+### TDB
 
     <#dataset> rdf:type      tdb:DatasetTDB ;
         tdb:location "DB" ;
@@ -124,7 +221,7 @@
         ## tdb:unionDefaultGraph true ;
          .
 
-#### TDB2
+### TDB2
 
     <#dataset> rdf:type      tdb:DatasetTDB2 ;
         tdb:location "DB2" ;
@@ -134,7 +231,7 @@
         ## tdb:unionDefaultGraph true ;
          .
 
-#### Inference
+### Inference
 
 An inference reasoner can be layered on top of a dataset as defined above. The type of reasoner must be selected carefully and should not include more reasoning than is required by the application, as extensive reasoning can be detrimental to performance.
 
@@ -155,7 +252,7 @@
 
 where `http://example/someReasonerURLHere` is one of the URLs below.
 
-##### Possible reasoners:
+#### Possible reasoners:
 
 Details are in [the main documentation for inference](/documentation/inference/).
 
@@ -171,59 +268,28 @@
 
   The triples in the tbox (if present) will also be included in any query. Any of tbox or data graph are allowed to be null.
 
- * **RDFS Rule Reasoner**: `http://jena.hpl.hp.com/2003/RDFSExptRuleReasoner`
+  **RDFS Rule Reasoner**: `http://jena.hpl.hp.com/2003/RDFSExptRuleReasoner`
 
    A full implementation of RDFS reasoning using a hybrid rule system, together with optimized subclass/subproperty closure using the transitive graph caches. Implements the container membership property rules using an optional data scanning hook. Implements datatype range validation.
 
- * **Full OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLFBRuleReasoner`
-   
+* **Full OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLFBRuleReasoner`
+
    A hybrid forward/backward implementation of the OWL closure rules.
 
- * **Mini OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLMiniFBRuleReasoner`
-   
+* **Mini OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLMiniFBRuleReasoner`
+
    Key limitations over the normal OWL configuration are:
-   * omits the someValuesFrom => bNode entailments
-   * avoids any guard clauses which would break the find() contract
-   * omits inheritance of range implications for XSD datatype ranges
+  * omits the someValuesFrom => bNode entailments
+  * avoids any guard clauses which would break the find() contract
+  * omits inheritance of range implications for XSD datatype ranges
 
- * **Micro OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLMicroFBRuleReasoner`
+* **Micro OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLMicroFBRuleReasoner`
  
-   This only supports:
-   * RDFS entailments
-   * basic OWL axioms like ObjectProperty subClassOf Property
-   * intersectionOf, equivalentClass and forward implication of unionOf sufficient for traversal of explicit class hierarchies
-   * Property axioms (inverseOf, SymmetricProperty, TransitiveProperty, equivalentProperty)
+This only supports:
 
-   There is some experimental support for the cheaper class restriction handlingly which should not be relied on at this point.
+* RDFS entailments
+* basic OWL axioms like ObjectProperty subClassOf Property
+* intersectionOf, equivalentClass and forward implication of unionOf sufficient for traversal of explicit class hierarchies
+* Property axioms (inverseOf, SymmetricProperty, TransitiveProperty, equivalentProperty)
 
-## Server Configuration
-
-If you need to load additional classes, or set global parameters, then these go in
-`FUSEKI_BASE/config.ttl`.
-
-Additional classes can not be loaded if running as a `.war` file.  You will
-need to create a custom `.war` file consisting of the contents of the Fuseki
-web application and the additional classes
-
-### Server Section
-
-    [] rdf:type fuseki:Server ;
-       # Server-wide context parameters can be given here.
-       # For example, to set query timeouts: on a server-wide basis:
-       # Format 1: "1000" -- 1 second timeout
-       # Format 2: "10000,60000" -- 10s timeout to first result, then 60s timeout to for rest of query.
-       # See java doc for ARQ.queryTimeout
-       # ja:context [ ja:cxtName "arq:queryTimeout" ;  ja:cxtValue "10000" ] ;
-
-       # Load custom code (rarely needed)
-       # ja:loadClass "your.code.Class" ;
-       .
-
-## Compatibility with Fuseki 1 configuration
-
-Configurations from Fuseki 1, where all dataset and server setup is in a
-single configuration file, will still work.  It is less flexible
-(you can't restart these services after stopping them in a running server)
-and user should plan to migrate to the [new layout](./fuseki-layout.html).
-
-To convert a Fuseki 1 configuration setup to Fuseki 2 style, move each data service assembler and put in its own file under `FUSEKI_BASE/configuration/`
+ There is some experimental support for the cheaper class restriction handling which should not be relied on at this point.
diff --git a/source/documentation/fuseki2/data-access-control.md b/source/documentation/fuseki2/fuseki-data-access-control.md
similarity index 82%
rename from source/documentation/fuseki2/data-access-control.md
rename to source/documentation/fuseki2/fuseki-data-access-control.md
index b4b53d5..756c2f7 100644
--- a/source/documentation/fuseki2/data-access-control.md
+++ b/source/documentation/fuseki2/fuseki-data-access-control.md
@@ -7,16 +7,19 @@
 provides native https to protect data in-flight.
 
 [Fuseki Main](/documentation/fuseki2/fuseki-main.html)
-provides some common patterns of authentication.
-
-[Graph level Data Access Control](#graph-acl) provides control over the visibility of
+provides some common patterns of authentication and also 
+[Graph level Data Access Control](#graph-acl) to provide control over the visibility of
 graphs within a dataset, including the union graph of a dataset and
 the default graph. Currently, Graph level access control only applies to
 read-only datasets.
 
-Fuseki Full (Fuseki with the UI) can be used when
-[run in a web application server such as Tomcat](/documentation/fuseki2/fuseki-run.html#fuseki-web-application)
-to provide authentication of the user.  See "[Fuseki Security](fuseki-security)" for configuring security over the whole of the Fuseki UI.
+Fuseki Full (Fuseki with the UI) can be used when [run in a web application
+server such as
+Tomcat](/documentation/fuseki2/fuseki-webapp.html#fuseki-web-application) to
+provide authentication of the user.  See "[Fuseki Security](fuseki-security)"
+for configuring security over the whole of the Fuseki UI.
+
+This page applies to Fuseki Main.
 
 ## Contents
 
@@ -35,13 +38,12 @@
 
 ## HTTPS
 
-This section applies to Fuseki Main.
 HTTPS support is configured from the fuseki server command line.
 
 | Server Argument |    |  |
-|----------|----|--|
-| <tt>--https=<i>SETUP</i></tt>         | Name of file for certificate details.   | |
-| <tt>--httpsPort=<i>PORT</i></tt>     | The port for https   | Default: 3043 |
+| ----------------|----|--|
+| <tt>--https=<i>SETUP</i></tt>       | Name of file for certificate details.   | |
+| <tt>--httpsPort=<i>PORT</i></tt>    | The port for https   | Default: 3043 |
 
 The `--https` argument names a file in JSON which includes the name of
 the certificate file and password for the certificate.
@@ -75,8 +77,6 @@
 
 ## Authentication
 
-This section applies to Fuseki Main.
-
 [Authentication](https://en.wikipedia.org/wiki/Authentication),
 is establishing the identity of the principal (user or program) accessing the
 system. Fuseki Main provides users/password setup and HTTP authentication,
@@ -85,7 +85,7 @@
 
 These should be [used with HTTPS](#https).
 
-| Server Argument  |  |  |
+| Server Argument  |     |     |
 |------------------|-----|-----|
 | <tt>--passwd=<i>FILE</i></tt>  | Password file | |
 | <tt>--auth=</tt>               | "basic" or "digest"   | Default is "digest" |
@@ -132,10 +132,10 @@
 
 | wget argument  | Value |--|
 |----------------|-------|--|
-| `--http-user`  | user name | Set the user.
-| `--http-password` | password |  Set the password (visible to all on the local machine) |
-|   | | `wget` uses users/password from `.wgetrc` or `.netrc` by default. |
-| `--no-check-certificate` | |  Don't check HTTPS certificate.<br/> This allows for self-signed or expired, certificates or ones with the wrong host name. |
+| `--http-user`     | user name | Set the user. |
+| `--http-password` | password  |  Set the password (visible to all on the local machine) |
+|                   |           |  `wget` uses users/password from `.wgetrc` or `.netrc` by default. |
+| `--no-check-certificate` |    |  Don't check HTTPS certificate.<br/> This allows for self-signed or expired, certificates or ones with the wrong host name. |
 
 ## Access Control Lists {#acl}
 
@@ -205,14 +205,19 @@
         <b>fuseki:allowedUsers             "user1", "user3";</b>
 
         ## Choice of operations.
-        fuseki:serviceQuery             "query" ;
-        fuseki:serviceQuery             "sparql" ;
-        fuseki:serviceReadGraphStore    "get" ;
 
-        fuseki:serviceUpdate            "update" ;
-        fuseki:serviceUpload            "upload" ;
-        fuseki:serviceReadWriteGraphStore "data" ;
-
+        fuseki:endpoint [ 
+            fuseki:operation fuseki:query ;
+            fuseki:name "sparql" 
+        ];
+        fuseki:endpoint [
+            fuseki:operation fuseki:update ;
+            fuseki:name "sparql"
+        ] ;
+        fuseki:endpoint [
+            fuseki:operation fuseki:gsp-r ;
+            fuseki:name "get"
+        ] ;
         fuseki:dataset                  &lt;#base_dataset&gt;;
         .
 </pre>
@@ -223,10 +228,16 @@
 Again, any  other "allowedUsers" configuration, service-wide, or
 server-wide) also applies.
 
-        fuseki:serviceQuery  [ fuseki:name "query" ;
-                               fuseki:allowedUsers "user1", "user2"] ;
-        fuseki:serviceUpdate [ fuseki:name "update" ;
-                               fuseki:allowedUsers "user1"] ;
+         fuseki:endpoint [ 
+            fuseki:operation fuseki:query ;
+            fuseki:name "query" ;
+            fuseki:allowedUsers "user1", "user2" ;
+        ];
+        fuseki:endpoint [
+            fuseki:operation fuseki:update ;
+            fuseki:name "update" ;
+            fuseki:allowedUsers "user1"
+        ] ;
 
 Only <em>user1</em> can use SPARQL update; both <em>user1</em> and
 <em>user2</em> can use SPARQL query.
@@ -247,13 +258,13 @@
     &lt;#service_tdb2&gt; rdf:type fuseki:Service ;
         rdfs:label                      "Graph-level access controlled dataset" ;
         fuseki:name                     "db-graph-acl" ;
-        ## Read-only operations.
-        fuseki:serviceQuery             "query" ;
-        fuseki:serviceQuery             "sparql" ;
-        fuseki:serviceReadGraphStore    "get" ;
+        ## Read-only operations on the dataset URL.
+        fuseki:endpoint [ fuseki:operation fuseki:query ] ;
+        fuseki:endpoint [ fuseki:operation fuseki:gsp_r ] ;
         fuseki:dataset                  <b>&lt;#access_dataset&gt;</b> ;
         .
 
+    # Define access on the dataset.
     &lt;#access_dataset&gt;  rdf:type access:AccessControlledDataset ;
         access:registry   &lt;#securityRegistry&gt; ;
         access:dataset    &lt;#tdb_dataset_shared&gt; ;
diff --git a/source/documentation/fuseki2/fuseki-data-services.md b/source/documentation/fuseki2/fuseki-data-services.md
deleted file mode 100644
index a5e08c8..0000000
--- a/source/documentation/fuseki2/fuseki-data-services.md
+++ /dev/null
@@ -1,100 +0,0 @@
----
-title: "Fuseki : Data Services"
----
-
-Fuseki provides a number of "data services" - each data service is an RDF datasets
-and a configurable set of endpoints for various operations such as SPARQL query,
-SPARQL update and file upload.
-
-URI scheme.
-  Datasets and services
-  Admin
-
-## SPARQL Protocol
-
-Query
-update
-GSP including direct naming for GSP
-
-in addition:
-
-Dataset as a set of quads.
-
-
-----------------------------
-
-> _@@ Just rough notes : out-of-date and inconsistent_
-
-## Naming
-
-The naming style for application operations is:
-
-   / name / endpoint ? parameters
-
-where `name` is
-
-and `endpoint` is
-
-
-In the administration operations, the name is used after the 
-
-   /$/
-
-e.g. 
-
-In administration operations, the dataset name is appended to the operation.  For
-example, `http://host:port/$/datasets/ds` accesses the assembler description
-of the dataset.
-
-There is also an internal name, generated by the server which is a UUID.
-This UUID is never reused even if the dataset name is reused after the
-first use is deleted.
-
-## Services and Datasets
-
-Service 
-
-### Query
-
-    GEThttp://host:port/dataset?query=..
-
-    POST http://host:port/dataset
-    Content-type: application/sparql-query
-
-### Update
-
-    POST http://host:port/dataset?update=...
-    POST http://host:port/dataset?update
-
-or
-
-    POST http://host:port/dataset
-    Content-type: application/sparql-update
-
-### GSP
-
-    http://host:port/dataset?default
-    http://host:port/dataset?graph=...
-
-
-## The Dataset Lifecycle
-
-The lifecycle of a dataset 
-
-* Active 
-* Offline
-
-An *active* dataset is able to process applications requests. 
-
-An *offline* dataset is one whose configuration is know to the server but is currently not controlled by the server.
-
-When offline, the dataset is unavailable for application requests but the name remains in-use and the configuration information retained.  When made active again, the dataset and it's associated services are recreated.  When offline, Fuseki does not retain any access to the data so the dataset can be changed with tools outside of Fuseki.  When active, Fuseki assumes it has full control of a dataset (in particular TDB datasets can not be updated by other applications while active).
-
-When Fuseki is not running, all datasets can be considered offline even if they were not explicitly made so prior to shutdown of the server.
-
-
-(If a dataset uses in-memory storage, changes to its state are lost even though it is recreated from its; configuration when the server restarts.)
-
-
-## Links
-
diff --git a/source/documentation/fuseki2/fuseki-docker.md b/source/documentation/fuseki2/fuseki-docker.md
new file mode 100644
index 0000000..2aa52d3
--- /dev/null
+++ b/source/documentation/fuseki2/fuseki-docker.md
@@ -0,0 +1,112 @@
+---
+title: Fuseki : Docker Tools
+---
+
+The [jena-fuseki-docker package](https://repo1.maven.org/maven2/org/apache/jena/jena-fuseki-docker/)
+contains a Dockerfile, docker-compose file, and helper scripts to
+create a docker container for Apache Jena Fuseki.
+
+The docker container is based on 
+[Fuseki main](https://jena.apache.org/documentation/fuseki2/fuseki-main)
+for running a SPARQL server.
+
+There is no UI - all configuration is by command line and all usage by via the
+network protocols.
+
+Databases can be mounted outside the docker container so they are preserved when
+the container terminates.
+
+This build system allows the user to customize the docker image.
+
+The docker build downloads the server binary from 
+[Maven central](https://repo1.maven.org/maven2/org/apache/jena/jena-fuseki-server/),
+checking the download against the SHA1 checksum.
+
+## Database
+
+There is a volume mapping "./databases" in the current directory into the server.
+This can be used to contain databases outside, but accessible to, the container
+that do not get deleted when the container exits.
+
+See examples below.
+
+## Build
+
+Choose the version number of Apache Jena release you wish to use. This toolkit
+defaults to the version of the overall Jena release it was part of. It is best
+to use the release of this set of tools from the same release of the desired
+server.
+
+    docker-compose build --build-arg JENA_VERSION=3.16.0
+
+Note the build command must provide the version number.
+
+## Test Run
+
+`docker-compose run` cam be used to test the build from the previous section.
+
+Examples:
+
+Start Fuseki with an in-memory, updatable dataset at http://<i>host</i>:3030/ds
+
+    docker-compose run --rm --service-ports fuseki --mem /ds
+
+Load a TDB2 database, and expose, read-only, via docker:
+
+    mkdir -p databases/DB2
+    tdb2.tdbloader --loc databases/DB2 MyData.ttl
+    # Publish read-only
+    docker-compose run --rm --name MyServer --service-ports fuseki --tdb2 --loc databases/DB2 /ds
+
+To allow update on the database, add `--update`. Updates are persisted.
+
+    docker-compose run --rm --name MyServer --service-ports fuseki --tdb2 --update --loc databases/DB2 /ds
+
+See
+[fuseki-configuration](https://jena.apache.org/documentation/fuseki2/fuseki-configuration.html)
+for more information on command line arguments.
+
+To use `docker-compose up`, edit the `docker-compose.yaml` to set the Fuseki
+command line arguments appropriately.
+
+## Layout
+
+The default layout in the container is:
+
+| Path  | Use | 
+| ----- | --- |
+| /opt/java-minimal | A reduced size Java runtime                      |
+| /fuseki | The Fuseki installation                                    |
+| /fuseki/log4j2.properties | Logging configuration                    |
+| /fuseki/databases/ | Directory for a volume for persistent databases |
+
+## Setting JVM arguments
+
+Use `JAVA_OPTIONS`:
+
+    docker-compose run --service-ports --rm -e JAVA_OPTIONS="-Xmx1048m -Xms1048m" --name MyServer fuseki --mem /ds
+
+## Docker Commands
+
+If you prefer to use `docker` directly:
+
+Build:
+
+    docker build --force-rm --build-arg JENA_VERSION=3.16.0 -t fuseki .
+
+Run:
+
+    docker run -i --rm -p "3030:3030" --name MyServer -t fuseki --mem /ds
+
+With databases on a bind mount to host filesystem directory:
+
+    MNT="--mount type=bind,src=$PWD/databases,dst=/fuseki/databases"
+    docker run -i --rm -p "3030:3030" $MNT --name MyServer -t fuseki --tdb2 --update --loc databases/DB2 /ds
+
+## Version specific notes:
+
+* Versions of Jena up to 3.14.0 use Log4j1 for logging. The docker will build will ignore
+   the log4j2.properties file
+* Version 3.15.0: When run, a warning will be emitted.  
+  `WARNING: sun.reflect.Reflection.getCallerClass is not supported. This will impact performance.`  
+  This can be ignored.
diff --git a/source/documentation/fuseki2/fuseki-embedded.md b/source/documentation/fuseki2/fuseki-embedded.md
new file mode 100644
index 0000000..0faad60
--- /dev/null
+++ b/source/documentation/fuseki2/fuseki-embedded.md
@@ -0,0 +1,183 @@
+---
+title: Fuseki : Emdedded Server
+---
+
+Fuseki can be run within a larger JVM application as an embedded triplestore.
+
+* [Dependencies and Setup](#dependencies)
+* [Logging](#logging)
+* [Building a Server](#build)
+* [Examples](#examples)
+
+The application can safely access and modify the data published by the server if it does
+so inside a [transaction](/documentation/txn/) using an appropriate
+storage choice. `DatasetFactory.createTxnMem()` is a good choice for in-memory use;
+[TDB](/documentation/tdb/) is a good choice for a persistent database.
+
+To build and start the server:
+
+    Dataset ds = ...
+    FusekiServer server = FusekiServer.create()
+      .add("/rdf", ds)
+      .build() ;
+    server.start() ;
+
+then the application can modify the dataset:
+
+    // Add some data while live.
+    // Write transaction.
+    Txn.execWrite(dsg, ()->RDFDataMgr.read(dsg, "D.trig")) ;
+
+or read the dataset and see any updates made by remote systems:
+
+    // Query data while live
+    // Read transaction.
+    Txn.execRead(dsg, ()->{
+    Dataset ds = DatasetFactory.wrap(dsg) ;
+    try (QueryExecution qExec = QueryExecutionFactory.create("SELECT * { ?s  ?o}", ds) ) {
+        ResultSet rs = qExec.execSelect() ;
+        ResultSetFormatter.out(rs) ;
+      }
+    }) ;
+
+The full Jena API can be used provided operations (read and write) are inside
+a transaction.
+
+### Dependencies and Setup {#dependencies}
+
+To include an embedded Fuseki server in the application:
+
+    <dependency>
+      <groupId>org.apache.jena</groupId>
+      <artifactId>jena-fuseki-main</artifactId>
+      <version>3.x.y</version> <!-- Set the version -->
+    </dependency>
+
+This brings in enough dependencies to run Fuseki. Application writers are strongly
+encouraged to use a dependency manager because the number of Jetty and other dependencies
+is quite large and difficult to set manually.
+
+This dependency does not include a logging setting. Fuseki uses [slf4j](http://slf4j.org/).
+
+If the application wishes to use a dataset with a [text-index](/documentation/query/text-query.html)
+then the application will also need to include jena-text in its dependencies.
+
+### Logging {#logging}
+
+The application must set the logging provided for [slf4j](http://slf4j.org/).
+Apache Jena provides helpers Apache Log4j v2.
+
+For Apache Log4j2, call:
+
+    FusekiLogging.setLogging();
+
+and dependency:
+
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-slf4j-impl</artifactId>
+      <version>2.13.1</version> <!-- Many versions work -->  
+    </dependency>
+
+See [Fuseki Logging](/documentation/fuseki2/fuseki-logging.html).
+
+To silence logging from Java, try:
+
+    LogCtl.setLevel(Fuseki.serverLogName,  "WARN");
+    LogCtl.setLevel(Fuseki.actionLogName,  "WARN");
+    LogCtl.setLevel(Fuseki.requestLogName, "WARN");
+    LogCtl.setLevel(Fuseki.adminLogName,   "WARN");
+    LogCtl.setLevel("org.eclipse.jetty",   "WARN");
+
+## Building a server {#build}
+
+A ``FusekiServer`` is built by creating a configuration,
+building the server, then running it.  The application needs to start
+the server.
+
+The default port for a Fuseki embedded server is 3330. This is different for the default
+port for Fuseki running as a standalone server or as a webapp application.
+
+## Examples of embedded use {#examples}
+
+### Example 1
+Create a server on port 3330, that provides the default set of endpoints for an RDF
+dataset that can be updated via HTTP.
+
+    DatasetGraph ds = DatasetFactory.createTxnMem() ;
+    FusekiServer server = FusekiServer.create()
+        .add("/ds", ds)
+        .build() ;
+    server.start() ;
+    ...
+    server.stop() ;
+
+URLs:
+
+| Service | Endpoint |
+|---------|----------|
+| SPARQL Query      | ``http://host:3330/ds/query``   |
+| SPARQL Query      | ``http://host:3330/ds/sparql``  |
+| SPARQL Update     | ``http://host:3330/ds/update``  |
+| File upload       | ``http://host:3330/ds/update``  |
+| GSP read-write    | ``http://host:3330/ds/data``    |
+| Read-write quads  | ``http://host:3330/ds``         |
+
+"GSP" = SPARQL Graph Store Protocol
+
+### Example 2
+Create a server on port 3332, that provides the default set of endpoints for a data
+set that is read-only over HTTP. The application can still update the dataset.
+
+    Dataset ds = ... ;
+    FusekiServer server = FusekiServer.create()
+        .setPort(3332)
+        .add("/ds", ds, true)
+        .build() ;
+    server.start() ;
+
+| Service | Endpoint |
+|---------|----------|
+| SPARQL Query   | ``http://host:3332/ds/query``   |
+| SPARQL Query   | ``http://host:3332/ds/sparql``  |
+| GSP read-only  | ``http://host:3332/ds/data``    |
+| GET quads      | ``http://host:3332/ds``         |
+
+### Example 3
+
+Different combinations of services and endpoint names can be given using a `DataService`.
+
+    DatasetGraph dsg = ... ;
+    DataService dataService = new DataService(dsg) ;
+    dataService.addEndpoint(OperationName.Quads_RW, "");
+    dataService.addEndpoint(OperationName.Query, "");
+    dataService.addEndpoint(OperationName.Update, "");
+
+    FusekiServer server = FusekiServer.create()
+       .setPort(3332)
+       .add("/data", dataService)
+       .build() ;
+    server.start() ;
+
+This setup puts all the operation on the dataset URL. The ``Content-type`` and any query
+string is used to determine the operation.
+
+| Service | Endpoint |
+|---------|----------|
+| SPARQL Query    | ``http://host:3332/ds``  |
+| SPARQL Update   | ``http://host:3332/ds``  |
+| GSP read-only   | ``http://host:3332/ds``  |
+| GET/POST quads  | ``http://host:3332/ds``  |
+
+### Example 4
+
+Multiple datasets can be served by one server.
+
+    Dataset ds1 = ...
+    Dataset ds2 = ...
+    FusekiServer server = FusekiServer.create()
+        .add("/data1", ds1)
+        .add("/data1-readonly", ds1, true)
+        .add("/data2", ds2)
+        .build() ;
+    server.start() ;
diff --git a/source/documentation/fuseki2/fuseki-logging.md b/source/documentation/fuseki2/fuseki-logging.md
index 2d24bfd..55634c9 100644
--- a/source/documentation/fuseki2/fuseki-logging.md
+++ b/source/documentation/fuseki2/fuseki-logging.md
@@ -9,7 +9,6 @@
 the Tomcat configuration if running the WAR file.
 
 
-
 | Full Log name                   | Usage |
 |---------------                  |-------|
 | org.apache.jena.fuseki.Server   | General Server Messages              |
@@ -25,6 +24,7 @@
 Many web log analysers can process this format.
 
 This log is normally off.
+The logger name is `org.apache.jena.fuseki.Request`.
 
 When run as a WAR file inside a webapp container 
 (e.g. [Apache Tomcat](http://tomcat.apache.org/)), the webapp container
@@ -36,7 +36,7 @@
 
 * Use system property `log4j2.configurationFile` if defined ([as usual for log4j2](https://logging.apache.org/log4j/2.x/manual/configuration.html)).
 * Use `file:log4j2.properties` (current directory) if it exists
-* Use file `log4j2.properties` is the directory defined by `FUSEKI_BASE`
+* Use file `log4j2.properties` in the directory defined by `FUSEKI_BASE` (webapp)
 * Use java resource `log4j2.properties` on the classpath.
 * Use java resource `org/apache/jena/fuseki/log4j2.properties` on the classpath.
 * Use a built-in configuration.
@@ -45,10 +45,14 @@
 into a new WAR file and `org/apache/jena/fuseki/log4j.properties` omitted, or run from
 the base jar.  It is better to include `org/apache/jena/fuseki/log4j.properties`.
 
-The preferred customization is to use a custom `log4j2.properties` file in
-`FUSEKI_BASE`.  For the WAR file, `FUSEKI_BASE` defaults to `/etc/fuseki`
-on Linux.  For the standalone server, `FUSEKI_BASE` defaults to directory
-`run/` within the directory where the server is run.
+The preferred customization is to use a custom `log4j2.properties` file in the
+directory where Fuseki Main is run.
+
+For the war file packaging, the `log4j2.properties` should go in `FUSEKI_BASE`
+which defaults to `/etc/fuseki` on Linux.
+
+For the standalone webapp server, `FUSEKI_BASE` defaults to directory `run/`
+within the directory where the server is run.
 
 ## Default setting
 
@@ -59,7 +63,7 @@
 Below is an example logrotate(1) configuration (to go in `/etc/logrotate.d`)
 assuming the log file has been put in `/etc/fuseki/logs/fuseki.log`.
 
-It rotates the logs once a month, compresses logs on rotation and keeps them for 6 months.
+It rotates the logs once a month, compresses logs on rotation, and keeps them for 6 months.
 
 It uses `copytruncate`.  This may lead to at most one broken log file line.
 
diff --git a/source/documentation/fuseki2/fuseki-main.md b/source/documentation/fuseki2/fuseki-main.md
index d16e651..27c94d0 100644
--- a/source/documentation/fuseki2/fuseki-main.md
+++ b/source/documentation/fuseki2/fuseki-main.md
@@ -1,27 +1,27 @@
 ---
-title: "Fuseki : Main Server"
+title: Fuseki : Main Server
 ---
 
 Fuseki main is a packaging of Fuseki as a triple store without a UI for administration.
 
-
 Fuseki can be run in the background by an application as an embedded server.  The
 application can safely work with the dataset directly from java while having Fuseki
 provide SPARQL access over HTTP.  An embedded server is useful for
 adding functionality around a triple store and also for development and testing.
 
 * [Running as a deployment or development server](#fuseki-server)
-* [Application Use](#usage)
-* [Dependencies and Setup](#dependencies)
-* [Logging](#logging)
-* [Building a Server](#build)
-* [Examples](#examples)
+* [Running from Docker](#fuseki-docker)
+* [Running as an embedded server](fuseki-embedded.html)
+    * [Dependencies and Setup](fuseki-embedded.html#dependencies)
+    * [Logging](fuseki-embedded.html#logging)
+    * [Building a Server](fuseki-embedded.html#build)
+    * [Examples](fuseki-embedded.html#examples)
 
 The main server does not depend on any files on disk (other than for
 databases provided by the application), and does not provide the Fuseki
 UI or admins functions to create dataset via HTTP.
 
-See also [Data Access Control for Fuseki](data-access-control).
+See also [Data Access Control for Fuseki](./fuseki-data-access-control.html).
 
 ## Running as a configured deployment or development server {#fuseki-server}
 
@@ -33,201 +33,38 @@
     java -jar jena-fuseki-server-$VER.jar --help
 
 The arguments are the same as the 
-[full UI server command line program](/documentation/fuseki2/fuseki-run.html#fuseki-standalone-server).
+[full UI server command line program](/documentation/fuseki2/fuseki-webapp.html#fuseki-standalone-server).
 There are no special environment variables.
 
-
 The entry point is `org.apache.jena.fuseki.main.cmds.FusekiMainCmd` so
 the server can also be run as:
 
     java -cp jena-fuseki-server-$VER.jar:...OtherJars... \
         org.apache.jena.fuseki.main.cmds.FusekiMainCmd ARGS
 
+## Docker {#fuseki-docker}
 
-## Application Use {#usage}
+A kit to build a container with docker or docker compose 
 
-The application can safely access and modify the data published by the server if it does
-so inside a [transaction](/documentation/txn/) using an appropriate
-storage choice. `DatasetFactory.createTxnMem()` is a good choice for in-memory use;
-[TDB](/documentation/tdb/) is a good choice for a persistent database.
+    https://repo1.maven.org/maven2/org/apache/jena/jena-fuseki-docker/
+
+Note: take care that databases are on mounted volumes if they are to persist
+after the container is removed.
+
+See the [Fuseki docker tools page](fuseki-docker.html) for details.
+
+## Running as an embedded server
+
+Fuseki can be run from inside an Java application to provide SPARQL
+services to application data. The application can continue to access and
+update the datasets served by the server.
 
 To build and start the server:
 
     Dataset ds = ...
     FusekiServer server = FusekiServer.create()
-      .add("/rdf", ds)
+      .add("/dataset", ds)
       .build() ;
     server.start() ;
 
-then the application can modify the dataset:
-
-    // Add some data while live.
-    // Write transaction.
-    Txn.execWrite(dsg, ()->RDFDataMgr.read(dsg, "D.trig")) ;
-
-or read the dataset and see any updates made by remote systems:
-
-    // Query data while live
-    // Read transaction.
-    Txn.execRead(dsg, ()->{
-    Dataset ds = DatasetFactory.wrap(dsg) ;
-    try (QueryExecution qExec = QueryExecutionFactory.create("SELECT * { ?s  ?o}", ds) ) {
-        ResultSet rs = qExec.execSelect() ;
-        ResultSetFormatter.out(rs) ;
-      }
-    }) ;
-
-The full Jena API can be used provided operations (read and write) are inside
-a transaction.
-
-## Dependencies and Setup {#dependencies}
-
-To include an embedded Fuseki server in the application:
-
-    <dependency>
-      <groupId>org.apache.jena</groupId>
-      <artifactId>jena-fuseki-main</artifactId>
-      <version>3.x.y</version> <!-- Set the version -->
-    </dependency>
-
-This brings in enough dependencies to run Fuseki. Application writers are strongly
-encouraged to use a dependency manager because the number of Jetty and other dependencies
-is quite large and difficult to set manually.
-
-This dependency does not include a logging setting. Fuseki uses [slf4j](http://slf4j.org/).
-See section "[Logging](#logging)" for details.
-
-If the application wishes to use a dataset with a [text-index](/documentation/query/text-query.html)
-then the application will also need to include jena-text in its dependencies.
-
-## Logging {#logging}
-
-The application must set the logging provided for [slf4j](http://slf4j.org/).
-Apache Jena provides helpers for the JDK-provided java logging and for Apache Log4j v2.
-
-Using the JDK-provided java logging:
-
-    LogCtl.setJavaLogging()
-
-and a dependency of:
-
-    <dependency>
-      <groupId>org.slf4j</groupId>
-      <artifactId>slf4j-jdk14</artifactId>
-      <version>1.x.y</version>
-    </dependency>
-
-For Apache Log4j2: - this is how the full Fuseki server sets its logging:
-
-    FusekiLogging.setLogging();
-
-and dependency:
-
-    <dependency>
-      <groupId>org.apache.logging.log4j</groupId>
-      <artifactId>log4j-slf4j-impl</artifactId>
-      <version>2.13.1</version> <!-- Many versions work -->  
-    </dependency>
-
-See [Fuseki Logging](/documentation/fuseki2/fuseki-logging.html).
-
-To silence logging from Java, try:
-
-    LogCtl.setLevel(Fuseki.serverLogName,  "WARN");
-    LogCtl.setLevel(Fuseki.actionLogName,  "WARN");
-    LogCtl.setLevel(Fuseki.requestLogName, "WARN");
-    LogCtl.setLevel(Fuseki.adminLogName,   "WARN");
-    LogCtl.setLevel("org.eclipse.jetty",   "WARN");
-
-## Building a server {#build}
-
-A ``FusekiServer`` is built by creating a configuration,
-building the server, then running it.  The application needs to start
-the server.
-
-The default port for a Fuseki embedded server is 3330. This is different for the default
-port for Fuseki running as a standalone server or as a webapp application.
-
-## Examples of embedded use {#examples}
-
-### Example 1
-Create a server on port 3330, that provides the default set of endpoints for an RDF
-dataset that can be updated via HTTP.
-
-    DatasetGraph ds = DatasetFactory.createTxnMem() ;
-    FusekiServer server = FusekiServer.create()
-        .add("/ds", ds)
-        .build() ;
-    server.start() ;
-    ...
-    server.stop() ;
-
-URLs:
-
-| Service | Endpoint |
-|---------|----------|
-| SPARQL Query      | ``http://host:3330/ds/query``   |
-| SPARQL Query      | ``http://host:3330/ds/sparql``  |
-| SPARQL Update     | ``http://host:3330/ds/update``  |
-| File upload       | ``http://host:3330/ds/update``  |
-| GSP read-write    | ``http://host:3330/ds/data``    |
-| Read-write quads  | ``http://host:3330/ds``         |
-
-"GSP" = SPARQL Graph Store Protocol
-
-### Example 2
-Create a server on port 3332, that provides the default set of endpoints for a data
-set that is read-only over HTTP. The application can still update the dataset.
-
-    Dataset ds = ... ;
-    FusekiServer server = FusekiServer.create()
-        .setPort(3332)
-        .add("/ds", ds, true)
-        .build() ;
-    server.start() ;
-
-| Service | Endpoint |
-|---------|----------|
-| SPARQL Query   | ``http://host:3332/ds/query``   |
-| SPARQL Query   | ``http://host:3332/ds/sparql``  |
-| GSP read-only  | ``http://host:3332/ds/data``    |
-| GET quads      | ``http://host:3332/ds``         |
-
-### Example 3
-
-Different combinations of services and endpoint names can be given using a `DataService`.
-
-    DatasetGraph dsg = ... ;
-    DataService dataService = new DataService(dsg) ;
-    dataService.addEndpoint(OperationName.Quads_RW, "");
-    dataService.addEndpoint(OperationName.Query, "");
-    dataService.addEndpoint(OperationName.Update, "");
-
-    FusekiServer server = FusekiServer.create()
-       .setPort(3332)
-       .add("/data", dataService)
-       .build() ;
-    server.start() ;
-
-This setup puts all the operation on the dataset URL. The ``Content-type`` and any query
-string is used to determine the operation.
-
-| Service | Endpoint |
-|---------|----------|
-| SPARQL Query    | ``http://host:3332/ds``  |
-| SPARQL Update   | ``http://host:3332/ds``  |
-| GSP read-only   | ``http://host:3332/ds``  |
-| GET/POST quads  | ``http://host:3332/ds``  |
-
-### Example 4
-
-Multiple datasets can be served by one server.
-
-    Dataset ds1 = ...
-    Dataset ds2 = ...
-    FusekiServer server = FusekiServer.create()
-        .add("/data1", ds1)
-        .add("/data1-readonly", ds1, true)
-        .add("/data2", ds2)
-        .build() ;
-    server.start() ;
+See [Fuseki embedded documentation](fuseki-embedded.html) for details and examples.
diff --git a/source/documentation/fuseki2/fuseki-old-config-endpoint.md b/source/documentation/fuseki2/fuseki-old-config-endpoint.md
new file mode 100644
index 0000000..c961f61
--- /dev/null
+++ b/source/documentation/fuseki2/fuseki-old-config-endpoint.md
@@ -0,0 +1,55 @@
+---
+title: Fuseki Data Service Configuration Syntax - Old Style
+---
+
+This page describes the original Fuseki2 server configuration syntax.
+
+Example:
+
+    ## Updatable dataset.
+
+    <#service1> rdf:type fuseki:Service ;
+        fuseki:name                       "ds" ;       # http://host:port/ds
+        fuseki:serviceQuery               "sparql" ;   # SPARQL query service
+        fuseki:serviceQuery               "query" ;    # SPARQL query service (alt name)
+        fuseki:serviceUpdate              "update" ;   # SPARQL update service
+        fuseki:serviceUpload              "upload" ;   # Non-SPARQL upload service
+        fuseki:serviceReadWriteGraphStore "data" ;     # SPARQL Graph Store Protocol (read and write)
+        fuseki:serviceReadGraphStore      "get" ;      # SPARQL Graph Store Protocol (read only)
+        fuseki:dataset                    <#dataset> ;
+        .
+
+`<#dataset>` refers to a dataset description in the same file.
+
+There are fixed set of services:
+
+| Service | Description |
+|---------|-------------|
+| fuseki:serviceQuery | SPARQL query service |
+| fuseki:serviceUpdate | SPARQL update service |
+| fuseki:serviceUpload | Non-SPARQL HTML file upload service |
+| fuseki:serviceReadGraphStore | SPARQL Graph Store Protocol (read)
+| fuseki:serviceReadWriteGraphStore | SPARQL Graph Store Protocol (read and write)
+
+Configuration syntax can be mixed. If there are both old style and new style
+configurations for the same endpoint, the new style configuration is used.
+
+Quads operations on dataset are implied if there is a SPARQL Graph Store
+Protocol service configured.
+
+If a request is made on the dataset (no service name in the request URL), then
+the dispatcher classifies the operation and looks for a named endpoint for that
+operation of any name. If one is found, that is used. 
+In the [full endpoint configuration syntax](fuseki-config-endpoint.html), the
+additional dataset services are specified explicitly.
+
+The equivalent of 
+
+        fuseki:serviceQuery               "sparql" ;
+
+is
+
+        fuseki:endpoint [ fuseki:operation fuseki:query ; ];
+        fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "sparql" ];
+
+and the two endpoint can have different context setting and security.
diff --git a/source/documentation/fuseki2/fuseki-quick-start.md b/source/documentation/fuseki2/fuseki-quick-start.md
index 9a62ad8..fc8e122 100644
--- a/source/documentation/fuseki2/fuseki-quick-start.md
+++ b/source/documentation/fuseki2/fuseki-quick-start.md
@@ -23,7 +23,7 @@
 2. Run `fuseki-server --loc=DATABASE /name`
 3. In a browser, go to `http://localhost:3030//query.html`
 
-More details on running Fuseki can be found [nearby](fuseki-run.html),
+More details on running Fuseki can be found [nearby](fuseki-webapp.html),
 including running as an operating system service and in a web app or
 servlet container such as [Apache Tomcat](http://tomcat.apache.org/) or
 [Jetty](http://eclipse.org/jetty).
diff --git a/source/documentation/fuseki2/fuseki-run.md b/source/documentation/fuseki2/fuseki-run.md
deleted file mode 100644
index 6d9892c..0000000
--- a/source/documentation/fuseki2/fuseki-run.md
+++ /dev/null
@@ -1,97 +0,0 @@
----
-title: Running Fuseki
----
-
-Fuseki can be run in a number of ways:
-
-* [As a standalone server](#fuseki-standalone-server)
-* [As a service](#fuseki-service) run by the operation system, for example, started when the machine
-* [As a Web Application](#fuseki-web-application) inside a container such as Apache Tomcat or Jetty
-boots.
-* [As a configurable SPARQL server](#fuseki-main)
-* [As a deployment and development standalone server](#fuseki-server)
-
-See "[Fuseki Configuration](fuseki-configuration.html)" for information on
-how to provide datasets and configure services.
-
-## Fuseki as a Standalone Server {#fuseki-standalone-server}
-
-This is running Fuseki from the command line.
-
-    fuseki-server [--mem | --loc=DIR] [[--update] /NAME]
-
-    fuseki-server --config=CONFIG
-
-where `/NAME` is the dataset publishing name at this server in URI space.
-
-The argument `--tdb2` puts the command line handling into "TDB2 mode".
-A dataset created with `--loc` is a TDB2 dataset.
-
-See `fuseki-server --help` for details of more arguments.
-
-`FUSEKI_BASE`, the runtime area for the server instance, defaults to the
-`run/` directory of the current directory.
-
-Fuseki v2 supports the same style of configuration file as Fuseki v1 but it
-is better to separate the data service definitions from the server
-configuration with one definition per file in `FUSEKI_BASE/configuration`;
-see "[Fuseki Configuration](fuseki-configuration.html)".
-
-If you get the error message `Can't find jarfile to run` then you either
-need to put a copy of `fuseki-server.jar` in the current directory or set
-the environment variable `FUSEKI_HOME` to point to an unpacked Fuseki
-distribution.
-
-Unlike Fuseki v1, starting with no dataset and no configuration is possible.
-Datasets can be added from the admin UI to a running server.
-
-## Fuseki as a Service {#fuseki-service}
-
-Fuseki can run as an operating system service, started when the server
-machine boots.  The script `fuseki` is a Linux `init.d` with the common
-secondary arguments of `start` and `stop`.
-
-Process arguments are read from `/etc/default/fuseki` including
-`FUSEKI_HOME` and `FUSEKI_BASE`.  `FUSEKI_HOME` should be the directory
-where the distribution was unpacked.
-
-## Fuseki as a Web Application {#fuseki-web-application}
-
-Fuseki can run from a
-[WAR](http://en.wikipedia.org/wiki/WAR_%28file_format%29) file.  Fuseki
-requires at least support for the Servlet 3.0 API (e.g. Apache Tomcat 7 or
-Jetty 8) as well as Java8.
-
-`FUSEKI_HOME` is not applicable.
-
-`FUSEKI_BASE` defaults to `/etc/fuseki` which must be a writeable
-directory.  It is initialised the first time Fuseki runs, including a
-[Apache Shiro](http://shiro.apache.org/) security file but this is only
-intended as a starting point.  It restricts use of the admin UI to the
-local machine.
-
-## Fuseki as Configurable and Embeddable SPARQL Server {#fuseki-main}
-
-Fuseki can be run from inside an Java application to provide SPARQL
-services to application data. The application can continue to access and
-update the datasets served by the server.
-
-Basic example:
-
-    Dataset ds = ...
-    FusekiServer server = FusekiServer.create()
-      .add("/dataset", ds)
-      .build() ;
-    server.start() ;
-
-See the [full documentation](fuseki-main.html) for details of
-configuration and working with data shared with the
-[Fuseki main server](fuseki-main.html) instance.
-
-## Fuseki-Server (no UI) {#fuseki-server}
-
-The artifact `org.apache.jena:jena-fuseki-server` is a packaging of
-the [Fuseki "main" server](fuseki-main.html) server that runs from 
-the command line.  Unlike the full Fuseki server, it is only configured
-from the command line and has no persistent work area on-disk. 
-It has full SPARQL and all storage options.
diff --git a/source/documentation/fuseki2/fuseki-security.md b/source/documentation/fuseki2/fuseki-security.md
index 0b01367..23f615f 100644
--- a/source/documentation/fuseki2/fuseki-security.md
+++ b/source/documentation/fuseki2/fuseki-security.md
@@ -2,7 +2,7 @@
 title: Security in Fuseki2
 ---
 
-Fuseki2 provides security by using  [Apache Shiro](http://shiro.apache.org/).
+Fuseki2 webapp provides security by using  [Apache Shiro](http://shiro.apache.org/).
 This is controlled by the configuration file `shiro.ini` located at
 `$FUSEKI_BASE/shiro.ini`. If not found, the server initializes with a default
 configuration. This can then be replaced or edited as required. An existing file
@@ -88,6 +88,3 @@
     /$/** = authcBasic,user[admin]
     # Everything else
     /**=anon
-    
-
-
diff --git a/source/documentation/fuseki2/fuseki-server-info.md b/source/documentation/fuseki2/fuseki-server-info.md
new file mode 100644
index 0000000..79d191f
--- /dev/null
+++ b/source/documentation/fuseki2/fuseki-server-info.md
@@ -0,0 +1,116 @@
+---
+title: "Fuseki: Server Information"
+---
+
+A Fuseki server keeps detailed statistics for each dataset and each service
+of a dataset keeps counters as to the number
+of incoming requests, number of successful requests, number of bad requests
+(i.e client errors), and number of failing requests (i.e. server errors).
+
+Statistics are available in JSON and in [Prometheus](https://prometheus.io/)
+format. The Prometheus data includes both database and JVM metrics.
+
+## Endpoints
+
+The following servers endpoints are available. They are present in Fuseki/UI;
+they need to be enabled with [Fuseki/main](fuseki-main.html), either on the
+command line or in the server configuration file with a boolean setting.
+
+| Endpoint | Config Property | Usage |
+|----------|-----------------|-------|
+|`/$/ping`   | `fuseki:pingEP`     | Server liveness endpoint   |
+|`/$/stats`  | `fuseki:statsEP`    | JSON format endpoint       |   
+|`/$/metrics`| `fuseki:metricsEP`  | Prometheus format endpoint |   
+
+## Ping
+
+The "ping" service can be used to test whether a Fuseki server is running.
+Calling this endpoint imposes minimal overhead on the server.  Requests return
+the current time as a plain text string so to show the ping is current.
+
+HTTP GET and HTTP POST are supported. The GET request is marked "no-cache".  
+
+## Structure of the Statistics Report
+
+The statistics report shows the endpoints for each dataset with total counts of requests,
+good request and bad requests.
+
+
+## Example
+
+Endpoints with the format "_1" etc are unnamed services of the dataset.
+
+    { 
+      "datasets" : {
+          "/ds" : {
+              "Requests" : 0 ,
+              "RequestsGood" : 0 ,
+              "RequestsBad" : 0 ,
+              "endpoints" : {
+                  "data" : {
+                      "RequestsBad" : 0 ,
+                      "Requests" : 0 ,
+                      "RequestsGood" : 0 ,
+                      "operation" : "gsp-rw" ,
+                      "description" : "Graph Store Protocol"
+                    } ,
+                  "_1" : {
+                      "RequestsBad" : 0 ,
+                      "Requests" : 0 ,
+                      "RequestsGood" : 0 ,
+                      "operation" : "gsp-rw" ,
+                      "description" : "Graph Store Protocol"
+                    } ,
+                  "_2" : {
+                      "RequestsBad" : 0 ,
+                      "Requests" : 0 ,
+                      "RequestsGood" : 0 ,
+                      "operation" : "query" ,
+                      "description" : "SPARQL Query"
+                    } ,
+                  "query" : {
+                      "RequestsBad" : 0 ,
+                      "Requests" : 0 ,
+                      "RequestsGood" : 0 ,
+                      "operation" : "query" ,
+                      "description" : "SPARQL Query"
+                    } ,
+                  "sparql" : {
+                      "RequestsBad" : 0 ,
+                      "Requests" : 0 ,
+                      "RequestsGood" : 0 ,
+                      "operation" : "query" ,
+                      "description" : "SPARQL Query"
+                    } ,
+                  "get" : {
+                      "RequestsBad" : 0 ,
+                      "Requests" : 0 ,
+                      "RequestsGood" : 0 ,
+                      "operation" : "gsp-r" ,
+                      "description" : "Graph Store Protocol (Read)"
+                    } ,
+                  "update" : {
+                      "RequestsBad" : 0 ,
+                      "Requests" : 0 ,
+                      "RequestsGood" : 0 ,
+                      "operation" : "update" ,
+                      "description" : "SPARQL Update"
+                    } ,
+                  "_3" : {
+                      "RequestsBad" : 0 ,
+                      "Requests" : 0 ,
+                      "RequestsGood" : 0 ,
+                      "operation" : "update" ,
+                      "description" : "SPARQL Update"
+                    } ,
+                  "upload" : {
+                      "RequestsBad" : 0 ,
+                      "Requests" : 0 ,
+                      "RequestsGood" : 0 ,
+                      "operation" : "upload" ,
+                      "description" : "File Upload"
+                    }
+                }
+            }
+        }
+    }
diff --git a/source/documentation/fuseki2/fuseki-server-protocol.md b/source/documentation/fuseki2/fuseki-server-protocol.md
index 16796f6..5f5a002 100644
--- a/source/documentation/fuseki2/fuseki-server-protocol.md
+++ b/source/documentation/fuseki2/fuseki-server-protocol.md
@@ -137,7 +137,7 @@
 `/$/stats` is  treated as a container for this information.
 
 > _@@ stats details_
-> See [Fuseki Statistics](fuseki-stats.html) for details of statistics kept by a Fuseki server.
+> See [Fuseki Server Information](fuseki-server-info.html) for details of statistics kept by a Fuseki server.
 
 ### Backup 
 Pattern: `/$/backup/*{name}*`
diff --git a/source/documentation/fuseki2/fuseki-stats.md b/source/documentation/fuseki2/fuseki-stats.md
deleted file mode 100644
index 3e1b4ea..0000000
--- a/source/documentation/fuseki2/fuseki-stats.md
+++ /dev/null
@@ -1,115 +0,0 @@
----
-title: "Fuseki: Service Statistics"
----
-
-A Fuseki server keeps detailed statistics for each dataset and each service
-of a dataset keeps counters as to the number
-of incoming requests, number of successful requests, number of bad requests
-(i.e client errors), and number of failing requests (i.e. server errors).
-Statistics are returned as JSON. They are also available via JMX.
-
-## Structure of the Statistics Report
-
-### SPARQL Protocol Service 
-
-Query and Update
-
-### SPARQL Graph Store Protocol
-
-inc extensions - dataset HTTP verbs.
-
-#### Other services.
-
-File upload.
-
-## Example
-
-	{ "datasets" : {
-		 "/ds" :
-		     { "Requests" : 0 ,
-	           "RequestsBad" : 0 ,
-	           "RequestsGood" : 0 ,
-	           "services" : {
- 	              "query" :
-	                 {"QueryExecErrors" : 0 ,
-	                  "QueryTimeouts" : 0 ,
-	                  "Requests" : 0 ,
-	                  "RequestsBad" : 0 ,
-	                  "RequestsGood" : 0 ,
-	                  "endpoints" : [ 
-	                      "query" ,
-	                      "sparql"
-	                    ]
-	                } ,
-	              "update" :
-	                 {"Requests" : 0 ,
-	                  "RequestsBad" : 0 ,
-	                  "RequestsGood" : 0 ,
-	                  "UpdateExecErrors" : 0 ,
-	                  "endpoints" : [ ]
-	                } ,
-	              "upload" :
-	                 {"Requests" : 0 ,
-	                  "RequestsBad" : 0 ,
-	                  "RequestsGood" : 0 ,
-	                  "endpoints" : [ ]
-	                } ,
-
-	             "gspRead" :
-	                 {"GSPdelete" : 0 ,
-	                  "GSPdeleteBad" : 0 ,
-	                  "GSPdeleteGood" : 0 ,
-	                  "GSPget" : 0 ,
-	                  "GSPgetBad" : 0 ,
-	                  "GSPgetGood" : 0 ,
-	                  "GSPhead" : 0 ,
-	                  "GSPheadBad" : 0 ,
-	                  "GSPheadGood" : 0 ,
-	                  "GSPoptions" : 0 ,
-	                  "GSPoptionsBad" : 0 ,
-	                  "GSPoptionsGood" : 0 ,
-	                  "GSPpatch" : 0 ,
-	                  "GSPpatchBad" : 0 ,
-	                  "GSPpatchGood" : 0 ,
-	                  "GSPpost" : 0 ,
-	                  "GSPpostBad" : 0 ,
-	                  "GSPpostGood" : 0 ,
-	                  "GSPput" : 0 ,
-	                  "GSPputBad" : 0 ,
-	                  "GSPputGood" : 0 ,
-	                  "Requests" : 0 ,
-	                  "RequestsBad" : 0 ,
-	                  "RequestsGood" : 0 ,
-	                  "endpoints" : [ "data" ]
-	                } ,
-	              "gspReadWrite" :
-	                 {"GSPdelete" : 0 ,
-	                  "GSPdeleteBad" : 0 ,
-	                  "GSPdeleteGood" : 0 ,
-	                  "GSPget" : 0 ,
-	                  "GSPgetBad" : 0 ,
-	                  "GSPgetGood" : 0 ,
-	                  "GSPhead" : 0 ,
-	                  "GSPheadBad" : 0 ,
-	                  "GSPheadGood" : 0 ,
-	                  "GSPoptions" : 0 ,
-	                  "GSPoptionsBad" : 0 ,
-	                  "GSPoptionsGood" : 0 ,
-	                  "GSPpatch" : 0 ,
-	                  "GSPpatchBad" : 0 ,
-	                  "GSPpatchGood" : 0 ,
-	                  "GSPpost" : 0 ,
-	                  "GSPpostBad" : 0 ,
-	                  "GSPpostGood" : 0 ,
-	                  "GSPput" : 0 ,
-	                  "GSPputBad" : 0 ,
-	                  "GSPputGood" : 0 ,
-	                  "Requests" : 0 ,
-	                  "RequestsBad" : 0 ,
-	                  "RequestsGood" : 0 ,
-	                  "endpoints" : [ ]
-	                }
-	            }
-	        }
-	    }
-	}
diff --git a/source/documentation/fuseki2/fuseki-webapp.md b/source/documentation/fuseki2/fuseki-webapp.md
new file mode 100644
index 0000000..135b11d
--- /dev/null
+++ b/source/documentation/fuseki2/fuseki-webapp.md
@@ -0,0 +1,94 @@
+---
+title: Running Fuseki with UI
+---
+
+Fuseki/UI can be run in a number of ways:
+
+* [As a standalone server](#fuseki-standalone-server)
+* [As a service](#fuseki-service) run by the operation system, for example, started when the machine
+* [As a Web Application](#fuseki-web-application) inside a container such as Apache Tomcat or Jetty
+boots.
+
+Fuseki is also packaged as a plain server ["Fuseki Main"](fuseki-main.html)
+with no UI for use as a configurable SPARQL server, for [building as a Docker
+container](fuseki-docker.html), and as a deployment and development standalone
+server.
+
+Both packaging used the same configuration file format, and in standalone server
+mode, the same command line arguments.
+
+See "[Fuseki Configuration](fuseki-configuration.html)" for information on
+how to provide datasets and configure services using the configuration file.
+
+## Fuseki as a Standalone Server {#fuseki-standalone-server}
+
+This is running Fuseki from the command line.
+
+To publish at <tt>http://<i>host</i>:3030/NAME</i></tt>:
+
+where `/NAME` is the dataset publishing name at this server in URI space.
+
+TDB1 database:
+
+    fuseki-server [--loc=DIR] [[--update] /NAME]
+
+The argument `--tdb2` puts the command line handling into "TDB2 mode".
+A dataset created with `--loc` is a TDB2 dataset.
+TDB2 database:
+
+    fuseki-server --tdb2 [--loc=DIR] [[--update] /NAME]
+
+In-memory, non-peristent database (always updatable):
+
+    fuseki-server --mem /NAME
+
+Load a file at start and provide it read-only:
+
+    fuseki-server --file=MyData.ttl /NAME
+
+where "MyData.ttl" can be any RDF format, both triples or quads. 
+
+Administrative functions are only available from "localhost".
+
+See `fuseki-server --help` for details of more arguments.
+
+## Layout
+
+When run from the command line, the server creates its work area in the
+directory named by environment variable `FUSEKI_BASE`. When run from the
+command line, this defaults to the current directory.
+
+[Fuseki layout](fuseki-layout.html)
+
+If you get the error message `Can't find jarfile to run` then you either
+need to put a copy of `fuseki-server.jar` in the current directory or set
+the environment variable `FUSEKI_HOME` to point to an unpacked Fuseki
+distribution.
+
+Starting with no dataset and no configuration is possible.
+Datasets can be added from the admin UI to a running server.
+
+## Fuseki as a Service {#fuseki-service}
+
+Fuseki can run as an operating system service, started when the server
+machine boots.  The script `fuseki` is a Linux `init.d` with the common
+secondary arguments of `start` and `stop`.
+
+Process arguments are read from `/etc/default/fuseki` including
+`FUSEKI_HOME` and `FUSEKI_BASE`.  `FUSEKI_HOME` should be the directory
+where the distribution was unpacked.
+
+## Fuseki as a Web Application {#fuseki-web-application}
+
+Fuseki can run from a
+[WAR](http://en.wikipedia.org/wiki/WAR_%28file_format%29) file.  Fuseki
+requires at least support for the Servlet 3.0 API (e.g. Apache Tomcat 7 or
+Jetty 8) as well as Java8.
+
+`FUSEKI_HOME` is not applicable.
+
+`FUSEKI_BASE` defaults to `/etc/fuseki` which must be a writeable
+directory.  It is initialised the first time Fuseki runs, including a
+[Apache Shiro](http://shiro.apache.org/) security file but this is only
+intended as a starting point.  It restricts use of the admin UI to the
+local machine.