diff --git a/docs/README.md b/docs/README.md
index f1c84bf2..24e15e27 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -14,6 +14,7 @@ Status legend: ✅ Implemented · 🚧 In progress · 📋 Proposed
 | [section-anchors](section-anchors.md) | ✅ Implemented | Display views generate fragment identifiers (`…/spaces/nanosuggestions#messages`) from their titles, with a copy-link handle and Ajax-aware scrolling |
 | [structural-position](structural-position.md) | ✅ Implemented | `gen:hasStructuralPosition` `<section>.<sub>.<label>` strings order & group views on a page; strict format, primary digits 3–7 (intro…outro) in use ([#279](https://github.com/knowledgepixels/nanodash/issues/279)) |
 | [space-namespace-prefixes](space-namespace-prefixes.md) | ✅ Implemented | `nt:hasPrefix "~~SPACE~~/"` / `"~~NAMESPACE~~"` mint resources under the space or maintained resource the form was opened from, with a picker when the `context` param determines none ([#571](https://github.com/knowledgepixels/nanodash/issues/571)) |
+| [new-uri-placeholder](new-uri-placeholder.md) | ✅ Implemented | `nt:NewUriPlaceholder` marks a placeholder whose value names a resource that does not exist yet; publishing is refused when that identifier is already in use ([#646](https://github.com/knowledgepixels/nanodash/issues/646)) |
 | [fill-modes](fill-modes.md) | ✅ Implemented | Publish-form fill modes (use / supersede / derive / override): which IDs & root definition are kept vs. re-minted; derive now resets root, new `override` mode added ([#527](https://github.com/knowledgepixels/nanodash/issues/527)) |
 | [space-ref-identity](space-ref-identity.md) | 🚧 In progress | A space's identity is IRI + root-definition NPID (rival roots = distinct spaces); ref-keyed `SpaceRepository` + ref-scoped per-space authority queries shipped; one-`Space`-per-ref identity + disambiguation UI still to come |
 | [shacl-alignment](shacl-alignment.md) | 📋 Proposed | Build on the SHACL standard: adopt `sh:`/`dash:` constraint terms inside templates (A) and export SHACL shapes for external validation (B) |
diff --git a/docs/new-uri-placeholder.md b/docs/new-uri-placeholder.md
new file mode 100644
index 00000000..c12d8927
--- /dev/null
+++ b/docs/new-uri-placeholder.md
@@ -0,0 +1,87 @@
+# New-URI placeholders
+
+**Status:** ✅ Implemented — [#646](https://github.com/knowledgepixels/nanodash/issues/646)
+
+## Goal
+
+Stop a form from silently attaching a new nanopublication to somebody else's resource.
+
+An identifier minted under the nanopublication's own namespace picks up its artifact code at
+signing time, so it is unique by construction. One built from a prefix is not: fill "Defining
+an open-ended Space" with the same name twice and both nanopublications claim
+`https://w3id.org/spaces/my-space`. The second does not fail — it quietly becomes further
+statements about the first one's space. A nanopublication cannot be edited afterwards, so
+this is worth catching before publishing rather than after.
+
+## The tag
+
+A template marks the placeholders whose value names a resource that **does not exist yet**,
+alongside the placeholder's own type:
+
+```turtle
+sub:space a nt:ExternalUriPlaceholder, nt:NewUriPlaceholder ;
+  nt:hasPrefix "https://w3id.org/spaces/" ;
+  rdfs:label "Space identifier" .
+```
+
+Before publishing, Nanodash asks whether any nanopublication already introduces the resulting
+IRI. If one does, the publication is refused and the offending identifier is named.
+
+## What is and is not checked
+
+The tag is the only thing that turns the check on, and it is the template author's
+declaration of intent rather than something Nanodash infers:
+
+- **Tagged** — checked, however the value was formed. A name placed under a prefix and an IRI
+  the user typed out in full are treated the same, because whether a value names something new
+  is a property of the field, not of how the text was assembled.
+- **Untagged** — never checked. It publishes exactly as before even if the IRI already exists.
+  This is deliberate: a field can perfectly well point at a resource that exists, and most do.
+
+Two things are exempt even when tagged:
+
+- **Identifiers under the nanopublication's own namespace.** The value at check time still
+  carries the `~~~ARTIFACTCODE~~~` marker rather than the IRI that ends up published, and the
+  artifact code makes it unique anyway.
+- **The identifiers a superseded or overridden source already carries.** A new version keeps
+  the resource it is a version of (see [fill-modes](fill-modes.md)), so finding that one in use
+  is the expected answer, not a collision.
+
+Note the shape of that second rule: it exempts the *identifier*, not the fill mode. Nothing
+re-mints a prefix-minted identifier for a new version — there is no artifact code in it to
+change — so editing the name while superseding defines a resource the source never had, and it
+can collide like any other. An identifier under the nanopublication's own namespace does change
+with the new artifact code, but those are excluded by the rule above and never reach the check.
+
+With no source to compare against, nothing is checked at all, so a fill Nanodash does not
+recognise leaves publishing exactly as it was.
+
+A query service that cannot be reached answers "not taken". A check that cannot be made is not
+evidence of a collision, and publishing should not depend on the query services being up.
+
+## Why not infer it
+
+An earlier version of this worked it out from the shape of the form: an IRI built from a
+prefix, declared as an introduced resource, not auto-escaped, not superseding. That reads
+intent out of mechanics. A prefix is a formatting device, and `nt:introduces` is attached by
+templates that take the IRI of a thing that already exists too — templates such as "Defining
+an open-ended Space with existing URI" exist precisely for that. Inference also missed the
+opposite case, a new identifier typed out in full with no prefix involved.
+
+Because a positive result blocks publishing outright, a false positive walls somebody out of a
+nanopublication they are entitled to make, and the error message would be telling them to
+change an identifier they had every right to use. Making it opt-in trades coverage for not
+being wrong: a template that has not asked for the check behaves as it always did.
+
+The cost is that existing templates get nothing until they are republished with the tag. Since
+templates are themselves nanopublications, that means a new version and the governance pointer
+moved with it.
+
+## Vocabulary
+
+`nt:NewUriPlaceholder` is `https://w3id.org/np/o/ntemplate/NewUriPlaceholder`, declared in
+`Template` next to the other terms awaiting a home in nanopub-java's `NTEMPLATE`.
+
+It says more than `nt:introduces`, which a template also attaches when the user supplies the
+IRI of something that already exists. "New" here is about the identifier being minted by this
+form, not about the resource being unfamiliar to the person filling it in.
diff --git a/src/main/java/com/knowledgepixels/nanodash/QueryApiAccess.java b/src/main/java/com/knowledgepixels/nanodash/QueryApiAccess.java
index 78686c66..f4655a06 100644
--- a/src/main/java/com/knowledgepixels/nanodash/QueryApiAccess.java
+++ b/src/main/java/com/knowledgepixels/nanodash/QueryApiAccess.java
@@ -449,6 +449,32 @@ public static boolean isNanopubLoaded(String nanopubId) throws FailedApiCallExce
         return r != null && !r.getData().isEmpty();
     }
 
+    /**
+     * Checks whether the given IRI has already been used as the identifier of a resource,
+     * i.e. whether some nanopublication already introduces it.
+     * <p>
+     * This is the question an identifier that carries no artifact code raises: nothing makes
+     * it unique, so the same form filled with the same name twice yields the same IRI, and
+     * the second nanopublication silently attaches itself to the first one's resource (#646).
+     * The lookup runs against the meta repository, where {@code npx:introduces} is indexed.
+     * <p>
+     * A query service that cannot be reached answers false: a check that cannot be made is
+     * not evidence of a collision, and publishing should not depend on the query services
+     * being up.
+     *
+     * @param uri The IRI to check.
+     * @return True if a nanopublication introducing the IRI was found.
+     */
+    public static boolean isUriIntroduced(String uri) {
+        try {
+            ApiResponse r = get(new QueryRef(GET_INTRODUCING_NANOPUB, "thing", uri));
+            return r != null && !r.getData().isEmpty();
+        } catch (Exception ex) {
+            logger.error("Could not check whether IRI '{}' is already introduced", uri, ex);
+            return false;
+        }
+    }
+
     /**
      * Extracts the query ID from a given query IRI.
      *
diff --git a/src/main/java/com/knowledgepixels/nanodash/component/PublishForm.java b/src/main/java/com/knowledgepixels/nanodash/component/PublishForm.java
index ed81c119..38e5a2d7 100644
--- a/src/main/java/com/knowledgepixels/nanodash/component/PublishForm.java
+++ b/src/main/java/com/knowledgepixels/nanodash/component/PublishForm.java
@@ -45,6 +45,7 @@
 import org.eclipse.rdf4j.model.vocabulary.RDFS;
 import org.nanopub.MalformedNanopubException;
 import org.nanopub.Nanopub;
+import org.nanopub.NanopubUtils;
 import org.nanopub.NanopubAlreadyFinalizedException;
 import org.nanopub.NanopubCreator;
 import org.nanopub.extra.security.SignNanopub;
@@ -691,6 +692,9 @@ protected void onSubmit() {
                 try {
                     Nanopub np = createNanopub();
                     logger.info("Nanopublication created: {}", np.getUri());
+                    if (!areNewUrisUnused()) {
+                        return;
+                    }
                     TransformContext tc = new TransformContext(SignatureAlgorithm.RSA, NanodashSession.get().getKeyPair(), NanodashSession.get().getUserIri(), false, false, false);
                     signedNp = SignNanopub.signAndTransform(np, tc);
                     logger.info("Nanopublication signed: {}", signedNp.getUri());
@@ -1156,6 +1160,11 @@ public void onSubmit() {
                     }
 
                     Nanopub np = createNanopub();
+                    // Checked here too: the preview page publishes the nanopublication it
+                    // was given, without coming back through this form.
+                    if (!areNewUrisUnused()) {
+                        return;
+                    }
                     TransformContext tc = new TransformContext(SignatureAlgorithm.RSA, NanodashSession.get().getKeyPair(), NanodashSession.get().getUserIri(), false, false, false);
                     Nanopub signedNp = SignNanopub.signAndTransform(np, tc);
                     String previewId = signedNp.getUri().stringValue();
@@ -1540,6 +1549,7 @@ private static void collectTemplateErrors(String part, TemplateContext context,
 
     private synchronized Nanopub createNanopub() throws MalformedNanopubException, NanopubAlreadyFinalizedException {
         assertionContext.getIntroducedIris().clear();
+        assertionContext.getNewUriIris().clear();
         assertionContext.getRolePropertyPins().clear();
         NanopubCreator npCreator = new NanopubCreator(targetNamespace);
         npCreator.setAssertionUri(vf.createIRI(targetNamespace + "assertion"));
@@ -1720,6 +1730,75 @@ private boolean canPublishFromSource(PageParameters pageParams) {
         return false;
     }
 
+    private boolean areNewUrisUnused() {
+        IRI takenId = findTakenNewUri(assertionContext);
+        if (takenId == null) {
+            return true;
+        }
+        feedbackPanel.error("The identifier " + takenId.stringValue()
+                + " is already in use. Pick a different one, or use a template for describing"
+                + " an existing resource if that is what you mean to do.");
+        return false;
+    }
+
+    /**
+     * Returns the first identifier the given assertion context forms for a placeholder the
+     * template marks as naming a resource that does not exist yet -- the IRI of a new space,
+     * say -- that is already in use, or null if all of them are free.
+     * <p>
+     * Such an identifier carries no artifact code, so nothing makes it unique: filling the
+     * same form with the same name twice yields the same IRI, and the second nanopublication
+     * silently extends the first one's resource instead of defining a new one. A
+     * nanopublication cannot be edited afterwards, so the collision is worth catching before
+     * publishing rather than after (#646).
+     * <p>
+     * Only a placeholder the template tags with {@link com.knowledgepixels.nanodash.template.Template#NEW_URI_PLACEHOLDER} is
+     * checked; everything else publishes as before, whether or not its IRI already exists.
+     * <p>
+     * Superseding and overriding exempt the identifiers the source already carries, since a new
+     * version keeps the resource it is a version of, and finding that one in use is the expected
+     * answer rather than a collision. They are not exempt wholesale: a prefix-minted identifier
+     * carries no artifact code, so nothing re-mints it for the new version, and editing the name
+     * while superseding defines a genuinely new resource that can collide like any other. (An
+     * identifier minted under the nanopublication's own namespace does change with the new
+     * artifact code, but those never reach here -- see TemplateContext#recordIfNewUri.) With no
+     * source to compare against, nothing is checked, so an unrecognised fill leaves publishing
+     * exactly as it was.
+     *
+     * @param assertionContext the assertion context, after its values have been processed
+     * @return the first identifier for a new resource that is already in use, or null if none is
+     */
+    public static IRI findTakenNewUri(TemplateContext assertionContext) {
+        FillMode fillMode = assertionContext.getFillMode();
+        Nanopub source = null;
+        if (fillMode == FillMode.SUPERSEDE || fillMode == FillMode.OVERRIDE) {
+            source = assertionContext.getReferenceNanopub();
+            if (source == null) return null;
+        }
+        for (IRI newUri : assertionContext.getNewUriIris()) {
+            if (source != null && isUsedIn(source, newUri)) continue;
+            if (QueryApiAccess.isUriIntroduced(newUri.stringValue())) return newUri;
+        }
+        return null;
+    }
+
+    /**
+     * Tells whether the given nanopublication already mentions the given IRI, which is how a
+     * superseding version says it is carrying the source's resource over rather than naming a
+     * new one. Every graph counts: the resource appears as a subject in the assertion and again
+     * under {@code npx:introduces} in the publication info.
+     *
+     * @param nanopub the nanopublication to look in
+     * @param iri     the identifier to look for
+     * @return true if the nanopublication uses the identifier
+     */
+    private static boolean isUsedIn(Nanopub nanopub, IRI iri) {
+        for (Statement st : NanopubUtils.getStatements(nanopub)) {
+            if (iri.equals(st.getSubject()) || iri.equals(st.getObject())) return true;
+        }
+        return false;
+    }
+
     /**
      * Returns the ID of the nanopublication that the given page parameters ask
      * to supersede or override, or null if they ask for neither.
diff --git a/src/main/java/com/knowledgepixels/nanodash/template/Template.java b/src/main/java/com/knowledgepixels/nanodash/template/Template.java
index 2af6a9be..7595e0e4 100644
--- a/src/main/java/com/knowledgepixels/nanodash/template/Template.java
+++ b/src/main/java/com/knowledgepixels/nanodash/template/Template.java
@@ -35,8 +35,8 @@ public class Template implements Serializable {
      */
     public static final String DEFAULT_TARGET_NAMESPACE = "https://w3id.org/np/";
 
-    // TODO Move this to the other ntemplate vocabulary terms in nanopub-java (added there in
-    // Nanopublication/nanopub-java#156; drop it once that release is picked up):
+    // TODO Move these to the other ntemplate vocabulary terms in nanopub-java (both added
+    // there in Nanopublication/nanopub-java#156; drop them once that release is picked up):
     /**
      * Type of a template whose filled content applies only to the specific nanopublication
      * it was published with, and is not carried over when that nanopublication is
@@ -44,6 +44,18 @@ public class Template implements Serializable {
      */
     public static final IRI TRANSIENT_TEMPLATE = vf.createIRI("https://w3id.org/np/o/ntemplate/TransientTemplate");
 
+    /**
+     * Type marking a URI placeholder whose value names a resource that does not exist yet,
+     * applied alongside the placeholder's own type. The publish form refuses to publish when
+     * such an identifier is already in use (#646).
+     * <p>
+     * This is the template author's statement of intent, and the only thing that turns the
+     * check on: nothing is checked for an untagged placeholder, however its value is formed.
+     * It says more than {@link org.nanopub.vocabulary.NTEMPLATE#INTRODUCED_RESOURCE}, which a
+     * template also attaches when the user supplies the IRI of a thing that already exists.
+     */
+    public static final IRI NEW_URI_PLACEHOLDER = vf.createIRI("https://w3id.org/np/o/ntemplate/NewUriPlaceholder");
+
     private final Nanopub nanopub;
     private String label;
     private String description;
@@ -582,10 +594,22 @@ public boolean isTrustyUriPlaceholder(IRI iri) {
     }
 
     /**
-     * Checks if the IRI is an auto-escape URI placeholder.
+     * Checks if the IRI is a placeholder for a URI that does not exist yet, i.e. one the
+     * template marks with {@link #NEW_URI_PLACEHOLDER}.
      *
      * @param iri the IRI to check.
-     * @return true if the IRI is an auto-escape URI placeholder, false otherwise.
+     * @return true if the IRI is a new-URI placeholder, false otherwise.
+     */
+    public boolean isNewUriPlaceholder(IRI iri) {
+        iri = transform(iri);
+        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NEW_URI_PLACEHOLDER);
+    }
+
+    /**
+     * Checks if the IRI is an auto-escape URI placeholder.
+     *
+     * @param iri the IRI to check
+     * @return true if it is an auto-escape placeholder
      */
     public boolean isAutoEscapePlaceholder(IRI iri) {
         iri = transform(iri);
diff --git a/src/main/java/com/knowledgepixels/nanodash/template/TemplateContext.java b/src/main/java/com/knowledgepixels/nanodash/template/TemplateContext.java
index f5f3a132..5db6034f 100644
--- a/src/main/java/com/knowledgepixels/nanodash/template/TemplateContext.java
+++ b/src/main/java/com/knowledgepixels/nanodash/template/TemplateContext.java
@@ -44,6 +44,7 @@ public class TemplateContext implements Serializable {
     private final Map<IRI, IModel<?>> componentModels = new HashMap<>();
     private Set<IRI> introducedIris = new HashSet<>();
     private Set<IRI> embeddedIris = new HashSet<>();
+    private Set<IRI> newUriIris = new LinkedHashSet<>();
     private Map<IRI, IRI> rolePropertyPins = new LinkedHashMap<>();
     private List<StatementItem> statementItems;
     private Set<IRI> iriSet = new HashSet<>();
@@ -533,6 +534,25 @@ public Set<IRI> getEmbeddedIris() {
         return embeddedIris;
     }
 
+    /**
+     * Returns the IRIs this context formed for placeholders the template marks as naming a
+     * resource that does not exist yet ({@link Template#NEW_URI_PLACEHOLDER}).
+     * <p>
+     * Such an identifier carries no artifact code, so nothing makes it unique: two people
+     * filling the same form with the same name arrive at the same IRI, and the second
+     * nanopublication silently extends the first one's resource. The publish form checks
+     * these against what has already been published (see #646).
+     * <p>
+     * Only the tag puts an IRI in here. How the value was formed makes no difference -- typed
+     * out in full, or a name placed under a prefix -- because whether a value names something
+     * new is the template author's call, not something to infer from the shape of the form.
+     *
+     * @return a set of IRIs for new resources, in the order they were processed
+     */
+    public Set<IRI> getNewUriIris() {
+        return newUriIris;
+    }
+
     /**
      * Returns the role-instantiation direction pins collected in this context, mapping
      * each filled/constant role predicate to its pin class
@@ -629,6 +649,7 @@ public Value processValue(Value value) {
                     if (v.matches("[^:# ]+")) v = targetNamespace + v;
                     if (Utils.isUriValue(v)) {
                         processedValue = vf.createIRI(v);
+                        recordIfNewUri(iri, (IRI) processedValue);
                     } else {
                         processedValue = vf.createLiteral(tfObject);
                     }
@@ -662,6 +683,7 @@ public Value processValue(Value value) {
                 if (!unresolvedPrefix) {
                     if (v.matches("[^:# ]+")) v = targetNamespace + v;
                     processedValue = vf.createIRI(v);
+                    recordIfNewUri(iri, (IRI) processedValue);
                 }
             }
         } else if (template.isIntroducedResource(iri)
@@ -751,6 +773,25 @@ public Value processValue(Value value) {
         return processedValue;
     }
 
+    /**
+     * Records an IRI formed for a placeholder the template marks as naming a resource that
+     * does not exist yet, so that the publish form can check it against the identifiers
+     * already in use (#646).
+     * <p>
+     * An untagged placeholder records nothing and is never checked, whatever its value looks
+     * like. An IRI still sitting under the nanopublication's own namespace is left out as
+     * well: its artifact code is substituted at signing time, which both makes it unique and
+     * means the value seen here is not the one that gets published.
+     *
+     * @param placeholder the placeholder the value was entered into
+     * @param iri         the IRI that was just formed
+     */
+    private void recordIfNewUri(IRI placeholder, IRI iri) {
+        if (!template.isNewUriPlaceholder(placeholder)) return;
+        if (iri.stringValue().startsWith(targetNamespace)) return;
+        newUriIris.add(iri);
+    }
+
     /**
      * Returns the statement items associated with this context.
      *
diff --git a/src/test/java/com/knowledgepixels/nanodash/QueryApiAccessTest.java b/src/test/java/com/knowledgepixels/nanodash/QueryApiAccessTest.java
index 20fa2a47..ddc93abc 100644
--- a/src/test/java/com/knowledgepixels/nanodash/QueryApiAccessTest.java
+++ b/src/test/java/com/knowledgepixels/nanodash/QueryApiAccessTest.java
@@ -69,4 +69,41 @@ void getQueryNameExtractsQueryNameFromValidIRI() {
         assertEquals(queryName, result);
     }
 
+    // An identifier minted under a prefix carries no artifact code, so whether it is free has
+    // to be asked of what has already been published (#646).
+    @Test
+    void isUriIntroducedReportsAnIdentifierThatIsAlreadyTaken() {
+        ApiResponse response = new ApiResponse();
+        ApiResponseEntry entry = new ApiResponseEntry();
+        entry.add("np", "https://w3id.org/np/RAMVfH7NHhyXFkvbdYYBtimoivyFpQl6CrXgoKgmjGE6I");
+        response.getData().add(entry);
+
+        try (MockedStatic<QueryAccess> mockQueryAccess = mockStatic(QueryAccess.class)) {
+            mockQueryAccess.when(() -> QueryAccess.get(any(QueryRef.class))).thenReturn(response);
+
+            assertTrue(QueryApiAccess.isUriIntroduced("https://w3id.org/spaces/example/bar"));
+        }
+    }
+
+    @Test
+    void isUriIntroducedReportsAnIdentifierThatIsFree() {
+        try (MockedStatic<QueryAccess> mockQueryAccess = mockStatic(QueryAccess.class)) {
+            mockQueryAccess.when(() -> QueryAccess.get(any(QueryRef.class))).thenReturn(new ApiResponse());
+
+            assertFalse(QueryApiAccess.isUriIntroduced("https://w3id.org/spaces/example/unused"));
+        }
+    }
+
+    // A check that cannot be made is not evidence of a collision: an unreachable query
+    // service must not be what stops someone from publishing.
+    @Test
+    void isUriIntroducedAnswersFalseWhenTheQueryFails() {
+        try (MockedStatic<QueryAccess> mockQueryAccess = mockStatic(QueryAccess.class)) {
+            mockQueryAccess.when(() -> QueryAccess.get(any(QueryRef.class)))
+                    .thenThrow(new APINotReachableException("no instance reachable"));
+
+            assertFalse(QueryApiAccess.isUriIntroduced("https://w3id.org/spaces/example/bar"));
+        }
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/com/knowledgepixels/nanodash/template/NewUriPlaceholderTest.java b/src/test/java/com/knowledgepixels/nanodash/template/NewUriPlaceholderTest.java
new file mode 100644
index 00000000..230bcac1
--- /dev/null
+++ b/src/test/java/com/knowledgepixels/nanodash/template/NewUriPlaceholderTest.java
@@ -0,0 +1,279 @@
+package com.knowledgepixels.nanodash.template;
+
+import com.knowledgepixels.nanodash.QueryApiAccess;
+import com.knowledgepixels.nanodash.WicketApplication;
+import com.knowledgepixels.nanodash.component.PublishForm;
+import com.knowledgepixels.nanodash.component.PublishForm.FillMode;
+import org.apache.wicket.model.Model;
+import org.apache.wicket.util.tester.WicketTester;
+import org.eclipse.rdf4j.model.IRI;
+import org.eclipse.rdf4j.model.Value;
+import org.eclipse.rdf4j.model.ValueFactory;
+import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
+import org.eclipse.rdf4j.model.vocabulary.RDF;
+import org.eclipse.rdf4j.model.vocabulary.RDFS;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+import org.nanopub.Nanopub;
+import org.nanopub.NanopubCreator;
+import org.nanopub.vocabulary.NTEMPLATE;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
+
+/**
+ * An identifier for a resource that does not exist yet carries no artifact code, so nothing
+ * makes it unique and the publish form has to check it against the identifiers already in use
+ * (#646). Which values those are is the template author's call, declared by tagging the
+ * placeholder with {@link Template#NEW_URI_PLACEHOLDER}: a tagged placeholder is checked
+ * however its value was formed, and an untagged one is never checked, even when its IRI is
+ * built from a prefix and already exists.
+ */
+class NewUriPlaceholderTest {
+
+    private static final ValueFactory vf = SimpleValueFactory.getInstance();
+
+    private static final String NP_URI = "https://w3id.org/np/RAAbCdEfGhIjKlMnOpQrStUvWxYz0123456789-_AbCdE";
+    private static final String TARGET_NAMESPACE = "https://w3id.org/np/~~~ARTIFACTCODE~~~/";
+    private static final String SPACE_PREFIX = "https://w3id.org/spaces/";
+    private static final String TOPIC_PREFIX = "https://w3id.org/topics/";
+
+    // As in "Defining an open-ended Space (with root definition)": a new resource named below
+    // a fixed prefix, tagged so that the identifier gets checked.
+    private static final IRI SPACE_FIELD = vf.createIRI(NP_URI + "/space");
+    // Tagged, but with no prefix: the user types the identifier of the new resource in full.
+    private static final IRI FULL_IRI_FIELD = vf.createIRI(NP_URI + "/fullIri");
+    // Prefixed and introduced, but untagged: nothing is checked for it.
+    private static final IRI TOPIC_FIELD = vf.createIRI(NP_URI + "/topic");
+    // Tagged but minted under the nanopublication itself, which the artifact code makes unique.
+    private static final IRI LOCAL_FIELD = vf.createIRI(NP_URI + "/local");
+
+    private MockedStatic<TemplateData> templateDataMockedStatic;
+
+    @BeforeEach
+    void setUp() {
+        new WicketTester(new WicketApplication());
+        templateDataMockedStatic = mockStatic(TemplateData.class);
+    }
+
+    @AfterEach
+    void tearDown() {
+        templateDataMockedStatic.close();
+    }
+
+    /**
+     * Builds a template with one placeholder per combination of tag and prefix that matters.
+     */
+    private TemplateContext spaceTemplateContext() throws Exception {
+        NanopubCreator creator = new NanopubCreator(NP_URI);
+        creator.addProvenanceStatement(vf.createStatement(creator.getAssertionUri(), RDFS.SEEALSO, creator.getAssertionUri()));
+        creator.addPubinfoStatement(vf.createStatement(creator.getNanopubUri(), RDFS.SEEALSO, creator.getNanopubUri()));
+        IRI templateNode = creator.getAssertionUri();
+        IRI stSpace = vf.createIRI(NP_URI + "/st1");
+        IRI stFullIri = vf.createIRI(NP_URI + "/st2");
+        IRI stTopic = vf.createIRI(NP_URI + "/st3");
+        IRI stLocal = vf.createIRI(NP_URI + "/st4");
+        creator.addAssertionStatement(templateNode, RDF.TYPE, NTEMPLATE.ASSERTION_TEMPLATE);
+        creator.addAssertionStatement(templateNode, RDFS.LABEL, vf.createLiteral("Defining a space"));
+        creator.addAssertionStatement(templateNode, NTEMPLATE.HAS_STATEMENT, stSpace);
+        creator.addAssertionStatement(templateNode, NTEMPLATE.HAS_STATEMENT, stFullIri);
+        creator.addAssertionStatement(templateNode, NTEMPLATE.HAS_STATEMENT, stTopic);
+        creator.addAssertionStatement(templateNode, NTEMPLATE.HAS_STATEMENT, stLocal);
+        creator.addAssertionStatement(stSpace, RDF.SUBJECT, SPACE_FIELD);
+        creator.addAssertionStatement(stSpace, RDF.PREDICATE, RDF.TYPE);
+        creator.addAssertionStatement(stSpace, RDF.OBJECT, vf.createIRI("https://w3id.org/kpxl/gen/terms/Space"));
+        creator.addAssertionStatement(stFullIri, RDF.SUBJECT, SPACE_FIELD);
+        creator.addAssertionStatement(stFullIri, RDF.PREDICATE, RDFS.SEEALSO);
+        creator.addAssertionStatement(stFullIri, RDF.OBJECT, FULL_IRI_FIELD);
+        creator.addAssertionStatement(stTopic, RDF.SUBJECT, SPACE_FIELD);
+        creator.addAssertionStatement(stTopic, RDF.PREDICATE, RDFS.COMMENT);
+        creator.addAssertionStatement(stTopic, RDF.OBJECT, TOPIC_FIELD);
+        creator.addAssertionStatement(stLocal, RDF.SUBJECT, SPACE_FIELD);
+        creator.addAssertionStatement(stLocal, RDF.PREDICATE, RDFS.ISDEFINEDBY);
+        creator.addAssertionStatement(stLocal, RDF.OBJECT, LOCAL_FIELD);
+
+        creator.addAssertionStatement(SPACE_FIELD, RDF.TYPE, NTEMPLATE.EXTERNAL_URI_PLACEHOLDER);
+        creator.addAssertionStatement(SPACE_FIELD, RDF.TYPE, NTEMPLATE.INTRODUCED_RESOURCE);
+        creator.addAssertionStatement(SPACE_FIELD, RDF.TYPE, Template.NEW_URI_PLACEHOLDER);
+        creator.addAssertionStatement(SPACE_FIELD, NTEMPLATE.HAS_PREFIX, vf.createLiteral(SPACE_PREFIX));
+        creator.addAssertionStatement(SPACE_FIELD, RDFS.LABEL, vf.createLiteral("Space identifier"));
+
+        creator.addAssertionStatement(FULL_IRI_FIELD, RDF.TYPE, NTEMPLATE.EXTERNAL_URI_PLACEHOLDER);
+        creator.addAssertionStatement(FULL_IRI_FIELD, RDF.TYPE, Template.NEW_URI_PLACEHOLDER);
+        creator.addAssertionStatement(FULL_IRI_FIELD, RDFS.LABEL, vf.createLiteral("identifier of the new record"));
+
+        creator.addAssertionStatement(TOPIC_FIELD, RDF.TYPE, NTEMPLATE.EXTERNAL_URI_PLACEHOLDER);
+        creator.addAssertionStatement(TOPIC_FIELD, RDF.TYPE, NTEMPLATE.INTRODUCED_RESOURCE);
+        creator.addAssertionStatement(TOPIC_FIELD, NTEMPLATE.HAS_PREFIX, vf.createLiteral(TOPIC_PREFIX));
+        creator.addAssertionStatement(TOPIC_FIELD, RDFS.LABEL, vf.createLiteral("the topic"));
+
+        creator.addAssertionStatement(LOCAL_FIELD, RDF.TYPE, NTEMPLATE.URI_PLACEHOLDER);
+        creator.addAssertionStatement(LOCAL_FIELD, RDF.TYPE, NTEMPLATE.LOCAL_RESOURCE);
+        creator.addAssertionStatement(LOCAL_FIELD, RDF.TYPE, Template.NEW_URI_PLACEHOLDER);
+        creator.addAssertionStatement(LOCAL_FIELD, RDFS.LABEL, vf.createLiteral("short id of the record"));
+
+        Template template = TemplateTestUtil.parseTemplate(creator.finalizeNanopub());
+
+        TemplateData templateDataMock = mock(TemplateData.class);
+        templateDataMockedStatic.when(TemplateData::get).thenReturn(templateDataMock);
+        when(templateDataMock.getTemplate(NP_URI)).thenReturn(template);
+
+        TemplateContext context = new TemplateContext(ContextType.ASSERTION, NP_URI, "statement", TARGET_NAMESPACE);
+        context.initStatements();
+        return context;
+    }
+
+    // The headline case: the user types "my-space" and the template's prefix turns it into a
+    // full IRI that nothing else guarantees to be free.
+    @Test
+    void aTaggedNameBelowAPrefixIsChecked() throws Exception {
+        TemplateContext context = spaceTemplateContext();
+        context.getComponentModels().put(SPACE_FIELD, Model.of("my-space"));
+        Value processed = context.processValue(SPACE_FIELD);
+        assertEquals(SPACE_PREFIX + "my-space", processed.stringValue());
+        assertTrue(context.getNewUriIris().contains(processed),
+                "a tagged placeholder has to be checked for collisions");
+    }
+
+    // The tag says the value names something new, so how the IRI was arrived at is beside the
+    // point: a typed-out IRI is checked exactly like a prefixed one.
+    @Test
+    void aTaggedIriTypedOutInFullIsChecked() throws Exception {
+        TemplateContext context = spaceTemplateContext();
+        context.getComponentModels().put(FULL_IRI_FIELD, Model.of("https://example.org/records/new-one"));
+        Value processed = context.processValue(FULL_IRI_FIELD);
+        assertEquals("https://example.org/records/new-one", processed.stringValue());
+        assertTrue(context.getNewUriIris().contains(processed),
+                "the tag decides, not whether a prefix was used");
+    }
+
+    // The point of making this opt-in: every template that does not ask for the check keeps
+    // publishing as before, prefix or no prefix, existing identifier or not.
+    @Test
+    void anUntaggedPlaceholderIsNeverChecked() throws Exception {
+        TemplateContext context = spaceTemplateContext();
+        context.getComponentModels().put(TOPIC_FIELD, Model.of("cats"));
+        Value processed = context.processValue(TOPIC_FIELD);
+        assertEquals(TOPIC_PREFIX + "cats", processed.stringValue());
+        assertFalse(context.getNewUriIris().contains(processed),
+                "an untagged placeholder is left alone even when its IRI is built from a prefix");
+        assertTrue(context.getIntroducedIris().contains(processed),
+                "being an introduced resource is not by itself a reason to check");
+    }
+
+    // A local resource picks up this nanopublication's artifact code at signing time, so the
+    // value seen here is not the one that gets published and there is nothing to look up.
+    @Test
+    void aTaggedResourceMintedUnderTheNanopubIsNotChecked() throws Exception {
+        TemplateContext context = spaceTemplateContext();
+        context.getComponentModels().put(LOCAL_FIELD, Model.of("record"));
+        Value processed = context.processValue(LOCAL_FIELD);
+        assertEquals(TARGET_NAMESPACE + "record", processed.stringValue());
+        assertFalse(context.getNewUriIris().contains(processed),
+                "an identifier carrying the nanopublication's artifact code is unique by construction");
+    }
+
+    // What the publish form does with all of the above: refuse the publication and name the
+    // identifier that is taken.
+    @Test
+    void aTakenIdentifierIsReported() throws Exception {
+        TemplateContext context = spaceTemplateContext();
+        context.getComponentModels().put(SPACE_FIELD, Model.of("example/bar"));
+        IRI newUri = (IRI) context.processValue(SPACE_FIELD);
+        try (MockedStatic<QueryApiAccess> q = mockStatic(QueryApiAccess.class)) {
+            q.when(() -> QueryApiAccess.isUriIntroduced(newUri.stringValue())).thenReturn(true);
+            assertEquals(newUri, PublishForm.findTakenNewUri(context));
+        }
+    }
+
+    @Test
+    void aFreeIdentifierLetsThePublicationThrough() throws Exception {
+        TemplateContext context = spaceTemplateContext();
+        context.getComponentModels().put(SPACE_FIELD, Model.of("nobody-took-this"));
+        context.processValue(SPACE_FIELD);
+        try (MockedStatic<QueryApiAccess> q = mockStatic(QueryApiAccess.class)) {
+            q.when(() -> QueryApiAccess.isUriIntroduced(anyString())).thenReturn(false);
+            assertNull(PublishForm.findTakenNewUri(context));
+        }
+    }
+
+    // An untagged placeholder must not even reach the query service: the check is off for it,
+    // not merely tolerant of what it finds.
+    @Test
+    void anUntaggedPlaceholderIsNotLookedUpAtAll() throws Exception {
+        TemplateContext context = spaceTemplateContext();
+        context.getComponentModels().put(TOPIC_FIELD, Model.of("cats"));
+        context.processValue(TOPIC_FIELD);
+        try (MockedStatic<QueryApiAccess> q = mockStatic(QueryApiAccess.class)) {
+            assertNull(PublishForm.findTakenNewUri(context));
+            q.verifyNoInteractions();
+        }
+    }
+
+    // A new version carries the source's resource over (docs/fill-modes.md), so finding that
+    // identifier in use is the expected answer rather than a collision.
+    @Test
+    void supersedingKeepsTheSourcesIdentifierWithoutAsking() throws Exception {
+        TemplateContext context = spaceTemplateContext();
+        context.setFillMode(FillMode.SUPERSEDE);
+        context.setFillSource(sourceUsing(SPACE_PREFIX + "example/bar"));
+        context.getComponentModels().put(SPACE_FIELD, Model.of("example/bar"));
+        context.processValue(SPACE_FIELD);
+        try (MockedStatic<QueryApiAccess> q = mockStatic(QueryApiAccess.class)) {
+            assertNull(PublishForm.findTakenNewUri(context));
+            q.verifyNoInteractions();
+        }
+    }
+
+    // Nothing re-mints a prefix-minted identifier for the new version, so editing the name
+    // while superseding defines a resource the source never had, which can collide like any
+    // other. Exempting the whole fill mode used to let this through unchecked.
+    @Test
+    void supersedingUnderANewNameIsCheckedLikeAnyOther() throws Exception {
+        TemplateContext context = spaceTemplateContext();
+        context.setFillMode(FillMode.SUPERSEDE);
+        context.setFillSource(sourceUsing(SPACE_PREFIX + "example/bar"));
+        context.getComponentModels().put(SPACE_FIELD, Model.of("example/renamed"));
+        IRI renamed = (IRI) context.processValue(SPACE_FIELD);
+        try (MockedStatic<QueryApiAccess> q = mockStatic(QueryApiAccess.class)) {
+            q.when(() -> QueryApiAccess.isUriIntroduced(renamed.stringValue())).thenReturn(true);
+            assertEquals(renamed, PublishForm.findTakenNewUri(context));
+        }
+    }
+
+    // With no source to compare against there is nothing to say whether the identifier is the
+    // one being carried over, so publishing is left exactly as it was.
+    @Test
+    void supersedingWithoutAKnownSourceAsksNothing() throws Exception {
+        TemplateContext context = spaceTemplateContext();
+        context.setFillMode(FillMode.SUPERSEDE);
+        context.getComponentModels().put(SPACE_FIELD, Model.of("example/bar"));
+        context.processValue(SPACE_FIELD);
+        try (MockedStatic<QueryApiAccess> q = mockStatic(QueryApiAccess.class)) {
+            assertNull(PublishForm.findTakenNewUri(context));
+            q.verifyNoInteractions();
+        }
+    }
+
+    /**
+     * Builds the nanopublication a supersede would be filled from: one that already describes
+     * the resource under the given identifier.
+     */
+    private Nanopub sourceUsing(String resourceIri) throws Exception {
+        NanopubCreator creator = new NanopubCreator("https://w3id.org/np/RASourceVersion0123456789-_AbCdEfGhIjKlMnOpQ");
+        IRI resource = vf.createIRI(resourceIri);
+        creator.addAssertionStatement(resource, RDF.TYPE, vf.createIRI("https://w3id.org/kpxl/gen/terms/Space"));
+        creator.addProvenanceStatement(vf.createStatement(creator.getAssertionUri(), RDFS.SEEALSO, creator.getAssertionUri()));
+        creator.addPubinfoStatement(vf.createStatement(creator.getNanopubUri(), RDFS.SEEALSO, creator.getNanopubUri()));
+        return creator.finalizeNanopub();
+    }
+
+}