diff --git a/content/documentation/fuseki2/fuseki-config-endpoint.html b/content/documentation/fuseki2/fuseki-config-endpoint.html
index 786607b..0855f41 100644
--- a/content/documentation/fuseki2/fuseki-config-endpoint.html
+++ b/content/documentation/fuseki2/fuseki-config-endpoint.html
@@ -345,7 +345,7 @@
 <p>An update is a POST where the body is &ldquo;application/sparql-update&rdquo; or an HTML
 form with field &ldquo;update=&rdquo;.</p>
 <p>A GSP operation has <code>?default</code> or <code>?graph=</code>.</p>
-<p>Quads operations have no query string and a have a <code>Content-Type</code> for a data in
+<p>Quads operations are also provided by GSP endpoints when there is no query string and a have a <code>Content-Type</code> for a data in
 a RDF triples or quads syntax.</p>
 <p>So, for example &ldquo;GET /dataset&rdquo; is a request to get all the triples and quads in the
 dataset. The syntax for the response is determined by content negotiation,
@@ -413,9 +413,9 @@
 GET, POST, PUT (not DELETE, that would be the dataset itself),
 and the request or response is one of the syntaxes for datasets
 (TriG, N-Quads, JSON-LD, TriX).</p>
+<p>The DSP (&ldquo;Dataset Store Protocol&rdquo;) operations provide operations similar to GSP
+but operating on the dataset, not a speciifc graph.</p>
 <p>Fuseki also provides [/documentation/io/rdf-binary.html](RDF Binary) for triples and quads.</p>
-<p>The quads extension applies when there is no <code>?default</code> or <code>?graph</code>.
-<code>GET</code> fetches the dataset in quads format, and <code>PUT</code> and <code>POST</code> take quads format data (N-Quads and Trig).</p>
 <h2 id="context">Context</h2>
 <p>Each operation execution is given a &ldquo;context&rdquo; - a set of name-value pairs.
 Internally, this is used for system registries, for the fixed &ldquo;current time&rdquo; for
diff --git a/content/documentation/fuseki2/fuseki-embedded.html b/content/documentation/fuseki2/fuseki-embedded.html
index 6f114f2..510f4e3 100644
--- a/content/documentation/fuseki2/fuseki-embedded.html
+++ b/content/documentation/fuseki2/fuseki-embedded.html
@@ -270,37 +270,35 @@
 ...
 server.stop() ;
 </code></pre>
+<p>The services are avilable on a named endpoint and also on the dataset URL itself.</p>
 <p>URLs:</p>
 <table>
 <thead>
 <tr>
 <th>Service</th>
-<th>Endpoint</th>
+<th>Endpoint1</th>
+<th>Endpoint2</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>SPARQL Query</td>
 <td><code>http://host:3330/ds/query</code></td>
+<td><code>http://host:3330/ds</code></td>
 </tr>
 <tr>
 <td>SPARQL Query</td>
 <td><code>http://host:3330/ds/sparql</code></td>
+<td><code>http://host:3330/ds</code></td>
 </tr>
 <tr>
 <td>SPARQL Update</td>
 <td><code>http://host:3330/ds/update</code></td>
-</tr>
-<tr>
-<td>File upload</td>
-<td><code>http://host:3330/ds/update</code></td>
+<td><code>http://host:3330/ds</code></td>
 </tr>
 <tr>
 <td>GSP read-write</td>
 <td><code>http://host:3330/ds/data</code></td>
-</tr>
-<tr>
-<td>Read-write quads</td>
 <td><code>http://host:3330/ds</code></td>
 </tr>
 </tbody>
@@ -312,7 +310,7 @@
 <pre><code>Dataset ds = ... ;
 FusekiServer server = FusekiServer.create()
     .port(3332)
-    .add(&quot;/ds&quot;, ds, true)
+    .add(&quot;/ds&quot;, ds, false)
     .build() ;
 server.start() ;
 </code></pre>
@@ -321,23 +319,23 @@
 <tr>
 <th>Service</th>
 <th>Endpoint</th>
+<th>Endpoint2</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>SPARQL Query</td>
 <td><code>http://host:3332/ds/query</code></td>
+<td><code>http://host:3332/ds</code></td>
 </tr>
 <tr>
 <td>SPARQL Query</td>
 <td><code>http://host:3332/ds/sparql</code></td>
+<td><code>http://host:3332/ds</code></td>
 </tr>
 <tr>
 <td>GSP read-only</td>
 <td><code>http://host:3332/ds/data</code></td>
-</tr>
-<tr>
-<td>GET quads</td>
 <td><code>http://host:3332/ds</code></td>
 </tr>
 </tbody>
@@ -346,7 +344,7 @@
 <p>Different combinations of services and endpoint names can be given using a <code>DataService</code>.</p>
 <pre><code>DatasetGraph dsg = ... ;
 DataService dataService = new DataService(dsg) ;
-dataService.addEndpoint(OperationName.Quads_RW, &quot;&quot;);
+dataService.addEndpoint(OperationName.GSP_RW, &quot;&quot;);
 dataService.addEndpoint(OperationName.Query, &quot;&quot;);
 dataService.addEndpoint(OperationName.Update, &quot;&quot;);
 
@@ -375,11 +373,7 @@
 <td><code>http://host:3332/ds</code></td>
 </tr>
 <tr>
-<td>GSP read-only</td>
-<td><code>http://host:3332/ds</code></td>
-</tr>
-<tr>
-<td>GET/POST quads</td>
+<td>GSP read-write</td>
 <td><code>http://host:3332/ds</code></td>
 </tr>
 </tbody>
diff --git a/content/documentation/geosparql/geosparql-assembler.html b/content/documentation/geosparql/geosparql-assembler.html
index c57572f..2e52f5f 100644
--- a/content/documentation/geosparql/geosparql-assembler.html
+++ b/content/documentation/geosparql/geosparql-assembler.html
@@ -238,7 +238,7 @@
     ja:data &lt;file:geosparql_data.ttl&gt; ;
     .
 </code></pre><p>The full assembler properties with the default settings is:</p>
-<pre><code>&lt;#geo_ds&gt; rdf:type geosparql:geosparqlDataset ;
+<pre><code>&lt;#geo_ds&gt; rdf:type geosparql:GeosparqlDataset ;
     # Build in-memory is absent.
     geosparql:spatialIndexFile     &quot;spatial.index&quot;;
 
diff --git a/content/documentation/index.xml b/content/documentation/index.xml
index 418d99b..697f4ba 100644
--- a/content/documentation/index.xml
+++ b/content/documentation/index.xml
@@ -183,10 +183,9 @@
       
       <guid>https://jena.apache.org/documentation/sparql-apis/</guid>
       <description>Jump to the &amp;ldquo;Changes&amp;rdquo; section.
-Overview The SPARQL specifications provide query, update and the graph store protocol (GSP).
+Overview The SPARQL specifications provide query, update and the graph store protocol (GSP). In addition, Jena provided store operations for named graph formats.
 For working with RDF data:
-   API GPI     Model Graph   Statement Triple   Resource Node   Literal Node   String Var   Dataset DatasetGraph    Quad    and for SPARQL,
-   API GPI     RDFConnection RDFLink   QueryExecution QueryExec   UpdateExecution UpdateExec   ResultSet RowSet   ModelStore GSP    Jena provides a single interface, RDFConnection for working with local and remote RDF data using these protocols in a unified way.</description>
+   API GPI     Model Graph   Statement Triple   Resource Node   Literal Node   String Var   Dataset DatasetGraph    Quad    and for SPARQL,</description>
     </item>
     
     <item>
diff --git a/content/documentation/io/rdf-input.html b/content/documentation/io/rdf-input.html
index 99356e3..1d5f811 100644
--- a/content/documentation/io/rdf-input.html
+++ b/content/documentation/io/rdf-input.html
@@ -352,14 +352,16 @@
 <code>RDFParser</code> which provides a builder pattern.  It has many options - see
 <a href="/documentation/javadoc/arq/org/apache/jena/riot/RDFParser.html">the javadoc for all details</a>.</p>
 <p>For example, to read Trig data, and set the error handler specially,</p>
-<pre><code>    // The parsers will do the necessary character set conversion.  
+<pre><code>    Dataset dataset;
+    // The parsers will do the necessary character set conversion.  
     try (InputStream in = new FileInputStream(&quot;data.some.unusual.extension&quot;)) {
-        RDFParser.create()
-            .source(in)
-            .lang(RDFLanguages.TRIG)
-            .errorHandler(ErrorHandlerFactory.errorHandlerStrict)
-            .base(&quot;http://example/base&quot;)
-            .parse(noWhere);
+        dataset = 
+            RDFParser.create()
+                .source(in)
+                .lang(RDFLanguages.TRIG)
+                .errorHandler(ErrorHandlerFactory.errorHandlerStrict)
+                .base(&quot;http://example/base&quot;)
+                .toDataset(noWhere);
     }
 </code></pre>
 <h2 id="logging">Logging</h2>
diff --git a/content/documentation/io/rdf-output.html b/content/documentation/io/rdf-output.html
index 2ce0eff..e12d819 100644
--- a/content/documentation/io/rdf-output.html
+++ b/content/documentation/io/rdf-output.html
@@ -556,10 +556,9 @@
 <h5 id="_setting-directive-style_"><em>Setting directive style</em></h5>
 <pre><code>    riot --set ttl:directiveStyle=sparql --pretty Turtle file1.rdf file2.nt ...
 </code></pre><p>and in code:</p>
-<pre><code>  RDFWriter.create()
+<pre><code>  RDFWriter.source(model)
      .set(RIOT.symTurtleDirectiveStyle, &quot;sparql&quot;)
      .lang(Lang.TTL)
-     .source(model)
      .output(System.out);
 </code></pre><h5 id="_base-uri_"><em>Base URI</em></h5>
 <p>Output can be written with relative URIs and no base. Note: such output is not
diff --git a/content/documentation/io/streaming-io.html b/content/documentation/io/streaming-io.html
index 6bc1471..2824e2c 100644
--- a/content/documentation/io/streaming-io.html
+++ b/content/documentation/io/streaming-io.html
@@ -197,7 +197,7 @@
 into your project and passing an appropriate <code>InputStream</code>/<code>OutputStream</code>
 implementation to Jena code e.g.</p>
 <pre><code>InputStream input =  new ZstdCompressorInputStream(....);
-RDFParser.source(input).lang(Lang.NQ).parse(graph);
+Graph graph = RDFParser.source(input).lang(Lang.NQ).toGraph();
 </code></pre>
 <h2 id="streamrdf">StreamRDF</h2>
 <p>The central abstraction is
diff --git a/content/documentation/sparql-apis/index.html b/content/documentation/sparql-apis/index.html
index 6b73627..ecb613d 100644
--- a/content/documentation/sparql-apis/index.html
+++ b/content/documentation/sparql-apis/index.html
@@ -181,7 +181,8 @@
 <p>The SPARQL specifications provide
 <a href="https://www.w3.org/TR/sparql11-query/">query</a>,
 <a href="https://www.w3.org/TR/sparql11-update/">update</a> and the
-<a href="https://www.w3.org/TR/sparql11-http-rdf-update/">graph store protocol</a> (GSP).</p>
+<a href="https://www.w3.org/TR/sparql11-http-rdf-update/">graph store protocol</a> (GSP).
+In addition, Jena provided store operations for named graph formats.</p>
 <p>For working with RDF data:</p>
 <table>
 <thead>
@@ -250,6 +251,10 @@
 <td><code>ModelStore</code></td>
 <td><code>GSP</code></td>
 </tr>
+<tr>
+<td><code>ModelStore</code></td>
+<td><code>DSP</code></td>
+</tr>
 </tbody>
 </table>
 <p>Jena provides a single interface, <a href="../rdfconnection"><code>RDFConnection</code></a> for
@@ -269,8 +274,9 @@
 and the API version is an adapter to convert to the Model API and related
 classes.</p>
 <p><code>UpdateProcessor</code> is a legacy name for <code>UpdateExecution</code></p>
-<p><code>GSP</code> provides the SPARQL Graph Store Protocol, including extensions for sending
-and receiving datasets, rather than individual graphs.</p>
+<p><code>GSP</code> provides the SPARQL Graph Store Protocol, and &lsquo;DSP&rsquo; (Dataset Store
+Protocol) provides for sending and receiving datasets, rather than individual
+graphs.</p>
 <p>Both API and GPI provide builders for detailed setup, particularly for remote
 usage over HTTP and HTTPS where detailed control of the HTTP requests is
 sometimes necessary to work with other triple stores.</p>
@@ -278,7 +284,8 @@
 common usage patterns are retained in <code>QueryExecutionFactory</code>,
 <code>UpdateExecutionFactory</code>. Note that any methods that involved Apache HttpClient
 objects have been removed.</p>
-<h2 id="changes">Changes from Jena 4.2.0 to Jena 4.3.0</h2>
+<h2 id="changes">Changes from Jena 4.2.0</h2>
+<h3 id="changes430">Changes at Jena 4.3.0</h3>
 <ul>
 <li>
 <p>Execution objects have a companion builder. This is especially important of
@@ -291,7 +298,7 @@
 authentication provided on top by Jena. <a href="./http-auth.html">See the authentiucation documentation</a>.</p>
 </li>
 <li>
-<p>Authentication support is uniformly applied to query, update, GSP and <code>SERVICE</code>.</p>
+<p>Authentication support is uniformly applied to query, update, GSP, DSP and <code>SERVICE</code>.</p>
 </li>
 <li>
 <p>HTTP/2 support</p>
@@ -330,6 +337,17 @@
 <code>RDFLink</code> provide APIs.</p>
 </li>
 </ul>
+<h3 id="changes450">Changes at Jena 4.5.0</h3>
+<p>Separate the dataset operations from the graph operations.</p>
+<ul>
+<li>
+<p>GSP - SPARQL Graph Store Protocol</p>
+</li>
+<li>
+<p>DSP - Dataset Store Protocol: HTTP GET, POST, PUT operations on the datatse,
+e.g. quad formats like TriG.</p>
+</li>
+</ul>
 <h2 id="substitution">Substitution</h2>
 <p>All query and update builders provide operations to use a query and substitute
 variables for concrete RDF terms in the execution.</p>
diff --git a/content/download/index.html b/content/download/index.html
index 09225aa..62737c9 100644
--- a/content/download/index.html
+++ b/content/download/index.html
@@ -188,9 +188,9 @@
 </thead>
 <tbody>
 <tr>
-<td><a href="[preferred]jena/source/jena-4.4.0-source-release.zip">jena-4.4.0-source-release.zip</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/source/jena-4.4.0-source-release.zip.sha512">SHA512</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/source/jena-4.4.0-source-release.zip.asc">PGP</a></td>
+<td><a href="[preferred]jena/source/jena-4.5.0-source-release.zip">jena-4.5.0-source-release.zip</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/source/jena-4.5.0-source-release.zip.sha512">SHA512</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/source/jena-4.5.0-source-release.zip.asc">PGP</a></td>
 </tr>
 </tbody>
 </table>
@@ -206,14 +206,14 @@
 </thead>
 <tbody>
 <tr>
-<td><a href="[preferred]jena/binaries/apache-jena-fuseki-4.4.0.tar.gz">apache-jena-fuseki-4.4.0.tar.gz</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-fuseki-4.4.0.tar.gz.sha512">SHA512</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-fuseki-4.4.0.tar.gz.asc">PGP</a></td>
+<td><a href="[preferred]jena/binaries/apache-jena-fuseki-4.5.0.tar.gz">apache-jena-fuseki-4.5.0.tar.gz</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-fuseki-4.5.0.tar.gz.sha512">SHA512</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-fuseki-4.5.0.tar.gz.asc">PGP</a></td>
 </tr>
 <tr>
-<td><a href="[preferred]jena/binaries/apache-jena-fuseki-4.4.0.zip">apache-jena-fuseki-4.4.0.zip</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-fuseki-4.4.0.zip.sha512">SHA512</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-fuseki-4.4.0.zip.asc">PGP</a></td>
+<td><a href="[preferred]jena/binaries/apache-jena-fuseki-4.5.0.zip">apache-jena-fuseki-4.5.0.zip</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-fuseki-4.5.0.zip.sha512">SHA512</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-fuseki-4.5.0.zip.asc">PGP</a></td>
 </tr>
 </tbody>
 </table>
@@ -229,14 +229,14 @@
 </thead>
 <tbody>
 <tr>
-<td><a href="[preferred]jena/binaries/apache-jena-4.4.0.tar.gz">apache-jena-4.4.0.tar.gz</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-4.4.0.tar.gz.sha512">SHA512</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-4.4.0.tar.gz.asc">PGP</a></td>
+<td><a href="[preferred]jena/binaries/apache-jena-4.5.0.tar.gz">apache-jena-4.5.0.tar.gz</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-4.5.0.tar.gz.sha512">SHA512</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-4.5.0.tar.gz.asc">PGP</a></td>
 </tr>
 <tr>
-<td><a href="[preferred]jena/binaries/apache-jena-4.4.0.zip">apache-jena-4.4.0.zip</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-4.4.0.zip.sha512">SHA512</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-4.4.0.zip.asc">PGP</a></td>
+<td><a href="[preferred]jena/binaries/apache-jena-4.5.0.zip">apache-jena-4.5.0.zip</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-4.5.0.zip.sha512">SHA512</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/binaries/apache-jena-4.5.0.zip.asc">PGP</a></td>
 </tr>
 </tbody>
 </table>
@@ -252,9 +252,9 @@
 </thead>
 <tbody>
 <tr>
-<td><a href="[preferred]jena/binaries/jena-fuseki-war-4.4.0.war">jena-fuseki-war-4.4.0.war</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/binaries/jena-fuseki-war-4.4.0.war.sha512">SHA512</a></td>
-<td align="center"><a href="https://downloads.apache.org/jena/binaries/jena-fuseki-war-4.4.0.war.asc">PGP</a></td>
+<td><a href="[preferred]jena/binaries/jena-fuseki-war-4.5.0.war">jena-fuseki-war-4.5.0.war</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/binaries/jena-fuseki-war-4.5.0.war.sha512">SHA512</a></td>
+<td align="center"><a href="https://downloads.apache.org/jena/binaries/jena-fuseki-war-4.5.0.war.asc">PGP</a></td>
 </tr>
 </tbody>
 </table>
diff --git a/content/index.xml b/content/index.xml
index 30773e7..459ee13 100644
--- a/content/index.xml
+++ b/content/index.xml
@@ -226,10 +226,9 @@
       
       <guid>https://jena.apache.org/documentation/sparql-apis/</guid>
       <description>Jump to the &amp;ldquo;Changes&amp;rdquo; section.
-Overview The SPARQL specifications provide query, update and the graph store protocol (GSP).
+Overview The SPARQL specifications provide query, update and the graph store protocol (GSP). In addition, Jena provided store operations for named graph formats.
 For working with RDF data:
-   API GPI     Model Graph   Statement Triple   Resource Node   Literal Node   String Var   Dataset DatasetGraph    Quad    and for SPARQL,
-   API GPI     RDFConnection RDFLink   QueryExecution QueryExec   UpdateExecution UpdateExec   ResultSet RowSet   ModelStore GSP    Jena provides a single interface, RDFConnection for working with local and remote RDF data using these protocols in a unified way.</description>
+   API GPI     Model Graph   Statement Triple   Resource Node   Literal Node   String Var   Dataset DatasetGraph    Quad    and for SPARQL,</description>
     </item>
     
     <item>
diff --git a/content/sitemap.xml b/content/sitemap.xml
index 62ee850..1776029 100644
--- a/content/sitemap.xml
+++ b/content/sitemap.xml
@@ -84,7 +84,7 @@
   
   <url>
     <loc>https://jena.apache.org/download/</loc>
-    <lastmod>2022-03-24T12:55:03+00:00</lastmod>
+    <lastmod>2022-05-01T16:21:01+01:00</lastmod>
   </url>
   
   <url>
@@ -104,7 +104,7 @@
   
   <url>
     <loc>https://jena.apache.org/documentation/sparql-apis/</loc>
-    <lastmod>2021-12-05T23:14:11+00:00</lastmod>
+    <lastmod>2022-02-06T18:02:48+00:00</lastmod>
   </url>
   
   <url>
@@ -324,12 +324,12 @@
   
   <url>
     <loc>https://jena.apache.org/documentation.html</loc>
-    <lastmod>2022-02-23T17:08:04+00:00</lastmod>
+    <lastmod>2022-03-24T12:53:53+00:00</lastmod>
   </url>
   
   <url>
     <loc>https://jena.apache.org/download.html</loc>
-    <lastmod>2022-03-24T12:55:03+00:00</lastmod>
+    <lastmod>2022-05-01T16:21:01+01:00</lastmod>
   </url>
   
   <url>
@@ -369,7 +369,7 @@
   
   <url>
     <loc>https://jena.apache.org/documentation/fuseki2/fuseki-embedded.html</loc>
-    <lastmod>2021-11-05T16:04:36+00:00</lastmod>
+    <lastmod>2022-02-06T18:02:11+00:00</lastmod>
   </url>
   
   <url>
@@ -379,7 +379,7 @@
   
   <url>
     <loc>https://jena.apache.org/documentation/fuseki2/fuseki-config-endpoint.html</loc>
-    <lastmod>2020-09-19T11:47:36+01:00</lastmod>
+    <lastmod>2022-02-06T18:02:11+00:00</lastmod>
   </url>
   
   <url>
@@ -439,7 +439,7 @@
   
   <url>
     <loc>https://jena.apache.org/documentation/geosparql/geosparql-assembler.html</loc>
-    <lastmod>2022-02-09T20:52:34+00:00</lastmod>
+    <lastmod>2022-02-06T18:03:15+00:00</lastmod>
   </url>
   
   <url>
@@ -694,7 +694,7 @@
   
   <url>
     <loc>https://jena.apache.org/documentation/io/rdf-input.html</loc>
-    <lastmod>2021-12-05T22:49:42+00:00</lastmod>
+    <lastmod>2022-03-02T23:34:42+00:00</lastmod>
   </url>
   
   <url>
@@ -1149,12 +1149,12 @@
   
   <url>
     <loc>https://jena.apache.org/documentation/io/streaming-io.html</loc>
-    <lastmod>2021-11-01T11:43:24+00:00</lastmod>
+    <lastmod>2022-03-02T23:34:42+00:00</lastmod>
   </url>
   
   <url>
     <loc>https://jena.apache.org/documentation/io/rdf-output.html</loc>
-    <lastmod>2021-11-15T19:40:46+00:00</lastmod>
+    <lastmod>2022-03-24T12:53:53+00:00</lastmod>
   </url>
   
 </urlset>
\ No newline at end of file
