diff --git a/docs/README.md b/docs/README.md
index c021e989..2749a7c8 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -12,6 +12,7 @@ Status legend: ✅ Implemented · 🚧 In progress · 📋 Proposed
 | [magic-query-params](magic-query-params.md) | ✅ Implemented | Session-bound view-query placeholders (`LOCALPUBKEY`, `SITEURL`, `CURRENTUSER`); replaced the custom introductions table with proper views (`ProfileIntroItem` removed) |
 | [role-specific-views](role-specific-views.md) | ✅ Implemented | View **action buttons** gated to a role tier (Maintainer, …) or specific role, via `gen:isVisibleTo` on the action node |
 | [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)) |
 | [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/space-namespace-prefixes.md b/docs/space-namespace-prefixes.md
new file mode 100644
index 00000000..ff93b58c
--- /dev/null
+++ b/docs/space-namespace-prefixes.md
@@ -0,0 +1,113 @@
+# Space-/namespace-dependent prefixes in templates
+
+**Status:** ✅ Implemented — [#571](https://github.com/knowledgepixels/nanodash/issues/571)
+
+## Goal
+
+Let a template mint resources under **whichever space or maintained resource the form was
+opened from**, instead of a namespace the template author has to hard-code. Without this, a
+template that creates, say, a dataset record under a space needs one copy per space.
+
+A `nt:hasPrefix` value may now contain a placeholder standing for the currently applicable
+space or maintained-resource namespace:
+
+```
+sub:resource nt:hasPrefix "~~SPACE~~/"     .  # https://w3id.org/space/foo/bar/
+sub:resource nt:hasPrefix "~~SPACE~~/r/"   .  # https://w3id.org/space/foo/bar/r/
+sub:resource nt:hasPrefix "~~NAMESPACE~~"  .  # the current maintained resource's namespace
+```
+
+- **`~~SPACE~~`** stands for the IRI of the applicable space, **without** a trailing
+  separator — the template writes the separator it wants (`"~~SPACE~~/"`,
+  `"~~SPACE~~/r/"`, …).
+- **`~~NAMESPACE~~`** stands for the namespace of the current maintained resource
+  **including** its trailing separator: its declared namespace, or its own IRI plus `/`
+  when it declares none.
+
+Only one placeholder per prefix is meaningful; `~~SPACE~~` wins if both appear.
+
+## Where the value comes from
+
+The base is taken from the **navigation context** — the `context` URL parameter that
+Nanodash already carries across pages (`NavigationContext`), naming the space, maintained
+resource, or user a page was reached under:
+
+| Context resource | `~~SPACE~~` | `~~NAMESPACE~~` |
+| --- | --- | --- |
+| a space | the space's IRI | *unresolved* |
+| a maintained resource | the IRI of the space maintaining it | the resource's namespace |
+| a user, or no context | *unresolved* | *unresolved* |
+
+When the context determines no base, the form renders a **picker** in front of the
+placeholder's text field, offering the known spaces (for `~~SPACE~~`) or maintained
+resources (for `~~NAMESPACE~~`) by label. The context always wins when it does determine
+one: the picker only appears where it is actually needed, so the common case (publishing
+from a space page) stays a single-field form.
+
+## Implementation
+
+- **`DynamicPrefix`** (`com.knowledgepixels.nanodash`) owns the placeholder constants,
+  detects which one a raw prefix uses, resolves it against a context id, and lists the
+  selectable bases (from `SpaceRepository.findAll()` /
+  `MaintainedResourceRepository.findAll()`). `Template` is untouched: it keeps storing the
+  `nt:hasPrefix` literal verbatim, and resolution is a fill-time concern.
+- **`TemplateContext.getPrefix(IRI)`** is the resolved counterpart of
+  `Template.getPrefix(IRI)` and is what every consumer now calls (`IriTextfieldItem`,
+  `GuidedChoiceItem`, `ReadonlyItem`, the nanopub-label pattern in `PublishForm`, and
+  `processValue`). It returns null both when the template declares no prefix and when it
+  declares an unresolved dynamic one; `hasUnresolvedPrefix(IRI)` tells the two apart.
+  The navigation context is handed to the context via `setNavigationContextId`, which
+  `PublishForm` fills from its page parameters.
+- **The picked base** lives in a component model keyed by the **token**, not by the
+  placeholder (`TemplateContext.getPrefixModelKey(token)` → `local:prefix-base/SPACE`,
+  `local:prefix-base/NAMESPACE`). Every field whose prefix depends on the same thing —
+  including every repetition, and including fields with different suffixes such as
+  `~~SPACE~~/` and `~~SPACE~~/r/` — therefore shares **one** model instance. That is what
+  makes picking a space in one dropdown apply to all of them: the pickers share a model, so
+  the same shared-model AJAX refresh the form already uses for placeholders that appear in
+  several statements (`c.getDefaultModel() == choice.getModel()`) reaches every other
+  picker, and each field keeps its own suffix on top of the shared base. `~~SPACE~~` and
+  `~~NAMESPACE~~` keep separate models — they are different things picked from different
+  lists. The base is prefillable via the URL parameter `param_<postfix>__prefix` on any of
+  the sharing placeholders (first one wins).
+- **A field under a dynamic prefix ignores its own `param_<postfix>`.** The field holds
+  only the name below the prefix, and the namespace comes from the context or the picker;
+  a parameter for it — in practice a full IRI — would land in the field and bypass the
+  prefix altogether. Dropping it makes a bare `~~SPACE~~` behave exactly like
+  `~~SPACE~~/r/`, whatever the prefix's trailing path is. Static prefixes are unaffected:
+  `param_<postfix>` prefills them as before.
+- **`IriTextfieldItem`** renders the picker (a select2 dropdown, `prefixchoice`) when the
+  prefix is dynamic and the navigation context resolves nothing. The dropdown is required
+  exactly when the paired text field holds something that isn't already a full URI, so an
+  untouched optional field and a fully-typed-out URI both stay valid. The prefix used for
+  display, validation, and unification is re-resolved on every access (`PrefixModel`), so
+  picking a base updates the field without rebuilding the form.
+- **Publishing** with an unresolved prefix yields **no value** for the placeholder rather
+  than an IRI in the wrong namespace (`TemplateContext.processValue`); form validation
+  blocks the case anyway, this is the belt-and-braces half.
+
+## Deliberately out of scope
+
+Both are the "maybe for later" items of [#571](https://github.com/knowledgepixels/nanodash/issues/571):
+
+- **Always showing the picker**, with the context merely pre-selecting it. The context is
+  authoritative today; a picker that can silently contradict the page you are on is a
+  bigger UX decision than this issue needed.
+- **Restricting the options to the user's own spaces.** The picker lists every known
+  space / maintained resource; publishing into one the user has no rights on is caught
+  downstream, not in the form.
+
+Also not covered: a dynamic prefix on a **restricted-choice** or **guided-choice**
+placeholder renders no picker (only `IriTextfieldItem` has one). Such a placeholder still
+resolves its prefix from the navigation context, and publishes nothing when it cannot —
+the natural placeholder type for "mint a resource under this space" is a plain URI
+placeholder.
+
+## Backwards compatibility
+
+- **Old templates, new code:** no deployed template uses the placeholders, so every prefix
+  is detected as static and handled exactly as before.
+- **New templates, old code:** an old Nanodash treats `"~~SPACE~~/"` as a literal prefix
+  and would publish IRIs starting with `~~SPACE~~/`. There is no graceful degradation
+  here, so don't put the placeholders in templates shared with instances that predate this
+  feature.
diff --git a/src/main/java/com/knowledgepixels/nanodash/DynamicPrefix.java b/src/main/java/com/knowledgepixels/nanodash/DynamicPrefix.java
new file mode 100644
index 00000000..ada78381
--- /dev/null
+++ b/src/main/java/com/knowledgepixels/nanodash/DynamicPrefix.java
@@ -0,0 +1,141 @@
+package com.knowledgepixels.nanodash;
+
+import com.knowledgepixels.nanodash.domain.AbstractResourceWithProfile;
+import com.knowledgepixels.nanodash.domain.MaintainedResource;
+import com.knowledgepixels.nanodash.domain.Space;
+import com.knowledgepixels.nanodash.repository.MaintainedResourceRepository;
+import com.knowledgepixels.nanodash.repository.SpaceRepository;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * The space-/namespace-dependent placeholders a template can use in an
+ * {@code nt:hasPrefix} value, so a template can mint resources under whichever space or
+ * maintained resource the form was opened from instead of a namespace hard-coded by the
+ * template author (see issue #571 and docs/space-namespace-prefixes.md):
+ *
+ * <pre>
+ * nt:hasPrefix "~~SPACE~~/"      → https://w3id.org/space/foo/bar/
+ * nt:hasPrefix "~~SPACE~~/r/"    → https://w3id.org/space/foo/bar/r/
+ * nt:hasPrefix "~~NAMESPACE~~"   → the current maintained resource's namespace
+ * </pre>
+ * <p>
+ * The base is taken from the navigation context (the {@code context} URL parameter); when
+ * that yields nothing, the form offers the user a choice among the known spaces /
+ * maintained resources instead.
+ */
+public class DynamicPrefix {
+
+    private DynamicPrefix() {
+    }
+
+    /**
+     * Placeholder standing for the IRI of the currently applicable space (no trailing
+     * separator; templates write {@code "~~SPACE~~/"}).
+     */
+    public static final String SPACE_TOKEN = "~~SPACE~~";
+
+    /**
+     * Placeholder standing for the namespace of the current maintained resource
+     * (including its trailing separator).
+     */
+    public static final String NAMESPACE_TOKEN = "~~NAMESPACE~~";
+
+    /**
+     * Returns the dynamic placeholder used in the given raw {@code nt:hasPrefix} value.
+     *
+     * @param rawPrefix the prefix as declared by the template, may be null
+     * @return {@link #SPACE_TOKEN}, {@link #NAMESPACE_TOKEN}, or null if the prefix is static
+     */
+    public static String getToken(String rawPrefix) {
+        if (rawPrefix == null) return null;
+        if (rawPrefix.contains(SPACE_TOKEN)) return SPACE_TOKEN;
+        if (rawPrefix.contains(NAMESPACE_TOKEN)) return NAMESPACE_TOKEN;
+        return null;
+    }
+
+    /**
+     * Resolves the base a token stands for from the navigation context.
+     *
+     * @param token     the token, as returned by {@link #getToken(String)}
+     * @param contextId the navigation context resource id (the {@code context} URL parameter)
+     * @return the base to substitute for the token, or null if the context doesn't determine one
+     */
+    public static String resolveFromContext(String token, String contextId) {
+        AbstractResourceWithProfile resource = NavigationContext.resolve(contextId);
+        if (resource == null) return null;
+        if (SPACE_TOKEN.equals(token)) {
+            // A maintained resource resolves to the space maintaining it; a space to itself.
+            Space space = resource.getSpace();
+            return space == null ? null : space.getId();
+        }
+        if (NAMESPACE_TOKEN.equals(token)) {
+            if (resource instanceof MaintainedResource maintainedResource) {
+                return getNamespace(maintainedResource);
+            }
+            return null;
+        }
+        return null;
+    }
+
+    /**
+     * The namespace to mint sub-resources of the given maintained resource under: its
+     * declared namespace, or its own IRI plus a separator if it declares none.
+     *
+     * @param resource the maintained resource
+     * @return the namespace, ending in a separator
+     */
+    public static String getNamespace(MaintainedResource resource) {
+        String namespace = resource.getNamespace();
+        if (namespace != null && !namespace.isBlank()) return namespace;
+        return resource.getId() + "/";
+    }
+
+    /**
+     * The bases the user can pick from when the navigation context doesn't determine one,
+     * mapped to their display labels and ordered by label.
+     *
+     * @param token the token, as returned by {@link #getToken(String)}
+     * @return the selectable bases, mapped to their labels; empty if the token is unknown
+     */
+    public static Map<String, String> getOptions(String token) {
+        Map<String, String> options = new LinkedHashMap<>();
+        if (SPACE_TOKEN.equals(token)) {
+            List<Space> spaces = new ArrayList<>(SpaceRepository.get().findAll());
+            spaces.sort(Comparator.comparing(DynamicPrefix::getLabel, String.CASE_INSENSITIVE_ORDER));
+            for (Space space : spaces) {
+                options.putIfAbsent(space.getId(), getLabel(space));
+            }
+        } else if (NAMESPACE_TOKEN.equals(token)) {
+            List<MaintainedResource> resources = new ArrayList<>(MaintainedResourceRepository.get().findAll());
+            resources.sort(Comparator.comparing(DynamicPrefix::getLabel, String.CASE_INSENSITIVE_ORDER));
+            for (MaintainedResource resource : resources) {
+                options.putIfAbsent(getNamespace(resource), getLabel(resource));
+            }
+        }
+        return options;
+    }
+
+    /**
+     * The name of what the user is picking, used as the selector's placeholder text and
+     * as its label in validation messages.
+     *
+     * @param token the token, as returned by {@link #getToken(String)}
+     * @return the human-readable name of the selection
+     */
+    public static String getSelectionLabel(String token) {
+        if (NAMESPACE_TOKEN.equals(token)) return "resource";
+        return "space";
+    }
+
+    private static String getLabel(AbstractResourceWithProfile resource) {
+        String label = resource.getLabel();
+        if (label == null || label.isBlank()) return resource.getId();
+        return label;
+    }
+
+}
diff --git a/src/main/java/com/knowledgepixels/nanodash/component/GuidedChoiceItem.java b/src/main/java/com/knowledgepixels/nanodash/component/GuidedChoiceItem.java
index 2a41caad..a4718625 100644
--- a/src/main/java/com/knowledgepixels/nanodash/component/GuidedChoiceItem.java
+++ b/src/main/java/com/knowledgepixels/nanodash/component/GuidedChoiceItem.java
@@ -118,7 +118,7 @@ public GuidedChoiceItem(String id, String parentId, final IRI iriP, boolean opti
             possibleValues.add(v.toString());
         }
 
-        prefix = template.getPrefix(iri);
+        prefix = context.getPrefix(iri);
         if (prefix == null) prefix = "";
         String prefixLabel = template.getPrefixLabel(iri);
         Label prefixLabelComp;
diff --git a/src/main/java/com/knowledgepixels/nanodash/component/IriTextfieldItem.html b/src/main/java/com/knowledgepixels/nanodash/component/IriTextfieldItem.html
index df80175e..d67078b5 100644
--- a/src/main/java/com/knowledgepixels/nanodash/component/IriTextfieldItem.html
+++ b/src/main/java/com/knowledgepixels/nanodash/component/IriTextfieldItem.html
@@ -7,7 +7,7 @@
 <body>
 
 <wicket:panel>
-<span class="tooltip"><a class="tooltiptext" wicket:id="prefixtooltiptext"></a><span wicket:id="prefix" class="valueitem"></span></span><input type="text" class="nanopub-textfield" wicket:id="textfield" />
+<span class="tooltip"><a class="tooltiptext" wicket:id="prefixtooltiptext"></a><span wicket:id="prefix" class="valueitem"></span></span><select wicket:id="prefixchoice" class="prefix-select"></select><input type="text" class="nanopub-textfield" wicket:id="textfield" />
 </wicket:panel>
 
 </body>
diff --git a/src/main/java/com/knowledgepixels/nanodash/component/IriTextfieldItem.java b/src/main/java/com/knowledgepixels/nanodash/component/IriTextfieldItem.java
index 203d016f..64da4661 100644
--- a/src/main/java/com/knowledgepixels/nanodash/component/IriTextfieldItem.java
+++ b/src/main/java/com/knowledgepixels/nanodash/component/IriTextfieldItem.java
@@ -1,5 +1,6 @@
 package com.knowledgepixels.nanodash.component;
 
+import com.knowledgepixels.nanodash.DynamicPrefix;
 import com.knowledgepixels.nanodash.LocalUri;
 import com.knowledgepixels.nanodash.Utils;
 import com.knowledgepixels.nanodash.template.Template;
@@ -11,6 +12,7 @@
 import org.apache.wicket.ajax.AjaxRequestTarget;
 import org.apache.wicket.ajax.form.OnChangeAjaxBehavior;
 import org.apache.wicket.behavior.AttributeAppender;
+import org.apache.wicket.markup.html.WebMarkupContainer;
 import org.apache.wicket.markup.html.basic.Label;
 import org.apache.wicket.markup.html.form.TextField;
 import org.apache.wicket.markup.html.link.ExternalLink;
@@ -27,17 +29,26 @@
 import org.nanopub.vocabulary.NTEMPLATE;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.wicketstuff.select2.ChoiceProvider;
+import org.wicketstuff.select2.Response;
+import org.wicketstuff.select2.Select2Choice;
 
 import java.net.URISyntaxException;
+import java.util.Collection;
+import java.util.Map;
 
 /**
  * A text field for entering IRIs, with a prefix label and validation.
  */
 public class IriTextfieldItem extends AbstractContextComponent {
 
-    private String prefix;
+    private IModel<String> prefixModel;
     private TextField<String> textfield;
     private IRI iri;
+    // Non-null if the template's prefix is space-/namespace-dependent and the base has to
+    // be picked by the user (see DynamicPrefix):
+    private String dynamicPrefixToken;
+    private Select2Choice<String> prefixChoice;
     private static final Logger logger = LoggerFactory.getLogger(IriTextfieldItem.class);
 
     /**
@@ -53,6 +64,11 @@ public IriTextfieldItem(String id, String parentId, final IRI iriP, boolean opti
         super(id, context);
         this.iri = iriP;
         final Template template = context.getTemplate();
+        // Note this deliberately includes local resources: "mint the new resource under the
+        // space / maintained resource instead of under the nanopublication" is the headline
+        // use case of the dynamic prefix, and such placeholders are typically declared
+        // nt:LocalResource + nt:IntroducedResource (issue #571).
+        dynamicPrefixToken = DynamicPrefix.getToken(template.getPrefix(iri));
         IModel<String> model = (IModel<String>) context.getComponentModels().get(iri);
         boolean modelIsNew = false;
         if (model == null) {
@@ -61,17 +77,27 @@ public IriTextfieldItem(String id, String parentId, final IRI iriP, boolean opti
             modelIsNew = true;
         }
         String postfix = Utils.getUriPostfix(iri);
-        if (modelIsNew && context.hasParam(postfix)) {
+        // A space-/namespace-dependent prefix decides this field's namespace from the
+        // navigation context (or the picker), and the field itself holds only the name
+        // below it. A "param_<postfix>" carrying a value for such a field fights that --
+        // typically with a full IRI, which bypasses the prefix altogether -- so it is
+        // ignored here, leaving the field to be filled the same way whatever the prefix's
+        // trailing path is.
+        if (modelIsNew && dynamicPrefixToken == null && context.hasParam(postfix)) {
             model.setObject(context.getParam(postfix));
         }
-        prefix = template.getPrefix(iri);
-        if (prefix == null) prefix = "";
-        if (template.isLocalResource(iri)) {
-            prefix = Utils.getUriPrefix(iri);
-        }
+        prefixModel = new PrefixModel(iri, context);
+        // The navigation context takes precedence; only when it determines no base does the
+        // user get to pick one.
+        boolean showPrefixChoice = dynamicPrefixToken != null
+                && DynamicPrefix.resolveFromContext(dynamicPrefixToken, context.getNavigationContextId()) == null;
+        String prefix = prefixModel.getObject();
         String prefixLabel = template.getPrefixLabel(iri);
         Label prefixLabelComp;
-        if (prefixLabel == null) {
+        // The picker names what is being chosen and shows the chosen base, so the template's
+        // static prefix label would only duplicate it (and read as a stray word in front of
+        // a dropdown).
+        if (prefixLabel == null || showPrefixChoice) {
             prefixLabelComp = new Label("prefix", "");
             prefixLabelComp.setVisible(false);
         } else {
@@ -82,20 +108,15 @@ public IriTextfieldItem(String id, String parentId, final IRI iriP, boolean opti
             prefixLabelComp = new Label("prefix", prefixLabel);
         }
         add(prefixLabelComp);
-        String prefixTooltip = prefix;
-        if (!prefix.isEmpty()) {
-            prefixTooltip += "...";
-            if (template.isLocalResource(iri)) {
-                prefixTooltip = LocalUri.PREFIX + "...";
-            }
-        }
-        add(new ExternalLink("prefixtooltiptext", "", prefixTooltip));
+        ExternalLink prefixTooltip = new ExternalLink("prefixtooltiptext", Model.of(""), new PrefixTooltipModel(iri, context));
+        prefixTooltip.setOutputMarkupId(true);
+        add(prefixTooltip);
         textfield = new TextField<>("textfield", model);
         if (!optional) textfield.setRequired(true);
-        if (template.isLocalResource(iri) || !prefix.isEmpty()) {
+        if (template.isLocalResource(iri) || !prefix.isEmpty() || dynamicPrefixToken != null) {
             textfield.add(new AttributeAppender("class", " short"));
         }
-        textfield.add(new Validator(iri, template, prefix, context));
+        textfield.add(new Validator(iri, template, prefixModel, context));
         context.getComponents().add(textfield);
         if (template.getLabel(iri) != null) {
             textfield.add(new AttributeModifier("placeholder", template.getLabel(iri).replaceFirst(" - .*$", "")));
@@ -119,6 +140,83 @@ protected void onUpdate(AjaxRequestTarget target) {
             textfield.add(AttributeAppender.append("class", "introduced"));
         }
         add(textfield);
+        if (showPrefixChoice) {
+            initPrefixChoice(prefixTooltip);
+        } else {
+            add(new WebMarkupContainer("prefixchoice").setVisible(false));
+        }
+    }
+
+    /**
+     * Renders the picker for the base of a space-/namespace-dependent prefix, used when the
+     * navigation context doesn't determine one (see docs/space-namespace-prefixes.md).
+     */
+    @SuppressWarnings("unchecked")
+    private void initPrefixChoice(ExternalLink prefixTooltip) {
+        final String token = dynamicPrefixToken;
+        // One model per token, shared by every field whose prefix depends on the same
+        // thing, so a base picked in one picker applies to all of them.
+        IRI prefixModelKey = TemplateContext.getPrefixModelKey(token);
+        IModel<String> baseModel = (IModel<String>) context.getComponentModels().get(prefixModelKey);
+        if (baseModel == null) {
+            baseModel = Model.of("");
+            context.getComponentModels().put(prefixModelKey, baseModel);
+        }
+        // Any of the sharing placeholders may carry the pre-fill parameter; the first
+        // one that does wins, and later ones leave an already-chosen base alone.
+        String prefixParam = Utils.getUriPostfix(iri) + TemplateContext.PREFIX_SUFFIX;
+        if (baseModel.getObject().isEmpty() && context.hasParam(prefixParam)) {
+            baseModel.setObject(context.getParam(prefixParam));
+        }
+        prefixChoice = new Select2Choice<String>("prefixchoice", baseModel, new PrefixChoiceProvider(token)) {
+
+            // The base is needed exactly when the postfix field holds something that isn't
+            // already a full URI; reading the raw input keeps this independent of
+            // processing order. An empty (optional) field needs no base.
+            @Override
+            public boolean isRequired() {
+                if (super.isRequired()) return true;
+                String raw = textfield.getInput();
+                return raw != null && !raw.isBlank() && !raw.matches("https?://.+");
+            }
+
+        };
+        prefixChoice.setLabel(Model.of(DynamicPrefix.getSelectionLabel(token)));
+        prefixChoice.getSettings().setCloseOnSelect(true);
+        prefixChoice.getSettings().setPlaceholder(DynamicPrefix.getSelectionLabel(token) + "...");
+        prefixChoice.getSettings().setAllowClear(true);
+        prefixChoice.getSettings().setWidth("16em");
+        Utils.setSelect2ChoiceMinimalEscapeMarkup(prefixChoice);
+        prefixChoice.add(new ValueItem.KeepValueAfterRefreshBehavior());
+        prefixChoice.add((IValidator<String>) s -> {
+            if (s.getValue() != null && !s.getValue().isEmpty() && !DynamicPrefix.getOptions(token).containsKey(s.getValue())) {
+                s.error(new ValidationError("Invalid choice"));
+            }
+        });
+        prefixChoice.add(new InvalidityHighlighting());
+        prefixChoice.add(new OnChangeAjaxBehavior() {
+
+            // Every other picker on the same token holds the very same model, so refresh
+            // them (and their prefix tooltips) the way shared placeholder fields are
+            // refreshed elsewhere -- otherwise they'd keep showing the old base until the
+            // next full render.
+            @Override
+            protected void onUpdate(AjaxRequestTarget target) {
+                for (Component c : context.getComponents()) {
+                    if (c == prefixChoice) continue;
+                    if (c.getDefaultModel() == prefixChoice.getModel()) {
+                        c.modelChanged();
+                        target.add(c);
+                        IriTextfieldItem sibling = c.findParent(IriTextfieldItem.class);
+                        if (sibling != null) target.add(sibling.get("prefixtooltiptext"));
+                    }
+                }
+                target.add(prefixTooltip);
+            }
+
+        });
+        context.getComponents().add(prefixChoice);
+        add(prefixChoice);
     }
 
     /**
@@ -127,6 +225,9 @@ protected void onUpdate(AjaxRequestTarget target) {
     @Override
     public void removeFromContext() {
         context.getComponents().remove(textfield);
+        if (prefixChoice != null) {
+            context.getComponents().remove(prefixChoice);
+        }
     }
 
     /**
@@ -136,6 +237,7 @@ public void removeFromContext() {
     public boolean isUnifiableWith(Value v) {
         if (v == null) return true;
         if (v instanceof IRI) {
+            String prefix = prefixModel.getObject();
             String vs = v.stringValue();
             if (vs.startsWith(prefix)) vs = vs.substring(prefix.length());
             if (Utils.isLocalURI(vs)) vs = vs.replaceFirst("^" + LocalUri.PREFIX, "");
@@ -146,7 +248,7 @@ public boolean isUnifiableWith(Value v) {
             if (context.getTemplate().isLocalResource(iri) && !Utils.isUriPostfix(vs)) {
                 vs = Utils.getUriPostfix(vs);
             }
-            new Validator(iri, context.getTemplate(), prefix, context).validate(validatable);
+            new Validator(iri, context.getTemplate(), prefixModel, context).validate(validatable);
             if (!validatable.isValid()) {
                 return false;
             }
@@ -164,6 +266,7 @@ public boolean isUnifiableWith(Value v) {
     @Override
     public void unifyWith(Value v) throws UnificationException {
         if (v == null) return;
+        String prefix = prefixModel.getObject();
         String vs = v.stringValue();
         if (!isUnifiableWith(v)) throw new UnificationException(vs);
         if (!prefix.isEmpty() && vs.startsWith(prefix)) {
@@ -179,6 +282,114 @@ public void unifyWith(Value v) throws UnificationException {
         textfield.setModelObject(vs);
     }
 
+    /**
+     * The prefix a placeholder's value is built on, re-resolved on every access so that a
+     * space-/namespace-dependent prefix picked after the form was built is taken into
+     * account. Empty (rather than null) when the prefix is undeclared or unresolved, so
+     * callers can concatenate without extra null checks.
+     */
+    private static class PrefixModel implements IModel<String> {
+
+        private final IRI iri;
+        private final TemplateContext context;
+
+        PrefixModel(IRI iri, TemplateContext context) {
+            this.iri = iri;
+            this.context = context;
+        }
+
+        @Override
+        public String getObject() {
+            // A dynamic prefix wins over the template-local prefix of a local resource:
+            // it is what the resource will actually be minted under (issue #571).
+            if (!context.hasDynamicPrefix(iri) && context.getTemplate().isLocalResource(iri)) {
+                return Utils.getUriPrefix(iri);
+            }
+            String prefix = context.getPrefix(iri);
+            return prefix == null ? "" : prefix;
+        }
+
+    }
+
+    /**
+     * The text shown in the prefix tooltip: the resolved prefix followed by an ellipsis, or
+     * the local-URI prefix for local resources; empty when there is no prefix to show.
+     */
+    private static class PrefixTooltipModel implements IModel<String> {
+
+        private final IRI iri;
+        private final TemplateContext context;
+
+        PrefixTooltipModel(IRI iri, TemplateContext context) {
+            this.iri = iri;
+            this.context = context;
+        }
+
+        @Override
+        public String getObject() {
+            if (!context.hasDynamicPrefix(iri) && context.getTemplate().isLocalResource(iri)) {
+                return LocalUri.PREFIX + "...";
+            }
+            String prefix = context.getPrefix(iri);
+            if (prefix == null || prefix.isEmpty()) return "";
+            return prefix + "...";
+        }
+
+    }
+
+    /**
+     * Offers the spaces / maintained resources a space-/namespace-dependent prefix can be
+     * based on.
+     */
+    private static class PrefixChoiceProvider extends ChoiceProvider<String> {
+
+        private final String token;
+
+        PrefixChoiceProvider(String token) {
+            this.token = token;
+        }
+
+        @Override
+        public String getDisplayValue(String choiceId) {
+            if (choiceId == null || choiceId.isEmpty()) return "";
+            String label = DynamicPrefix.getOptions(token).get(choiceId);
+            if (label == null || label.isBlank()) return choiceId;
+            return label + " (" + choiceId + ")";
+        }
+
+        @Override
+        public String getIdValue(String object) {
+            return object;
+        }
+
+        // Getting strange errors with Tomcat if this method is not overridden:
+        @Override
+        public void detach() {
+        }
+
+        @Override
+        public void query(String term, int page, Response<String> response) {
+            Map<String, String> options = DynamicPrefix.getOptions(token);
+            if (term == null) {
+                response.addAll(options.keySet());
+                return;
+            }
+            String lowerCaseTerm = term.toLowerCase();
+            for (Map.Entry<String, String> option : options.entrySet()) {
+                if (option.getKey().toLowerCase().contains(lowerCaseTerm)
+                        || option.getValue().toLowerCase().contains(lowerCaseTerm)) {
+                    response.add(option.getKey());
+                }
+            }
+        }
+
+        @Override
+        public Collection<String> toChoices(Collection<String> ids) {
+            return ids;
+        }
+
+    }
+
     /**
      * Validator class for validating IRI text fields.
      */
@@ -186,7 +397,7 @@ protected static class Validator extends InvalidityHighlighting implements IVali
 
         private IRI iri;
         private Template template;
-        private String prefix;
+        private IModel<String> prefixModel;
         private TemplateContext context;
 
         /**
@@ -198,16 +409,30 @@ protected static class Validator extends InvalidityHighlighting implements IVali
          * @param context  the template context containing models and components
          */
         public Validator(IRI iri, Template template, String prefix, TemplateContext context) {
+            this(iri, template, Model.of(prefix), context);
+        }
+
+        /**
+         * Constructor for creating a validator for an IRI text field whose prefix can change
+         * while the form is open (a space-/namespace-dependent prefix).
+         *
+         * @param iri         the IRI placeholder for this item
+         * @param template    the template containing validation rules
+         * @param prefixModel the model of the prefix to be used in validation
+         * @param context     the template context containing models and components
+         */
+        public Validator(IRI iri, Template template, IModel<String> prefixModel, TemplateContext context) {
             this.iri = iri;
             this.template = template;
-            this.prefix = prefix;
+            this.prefixModel = prefixModel;
             this.context = context;
         }
 
         @Override
         public void validate(IValidatable<String> s) {
             String sv = s.getValue();
-            String p = prefix;
+            String p = prefixModel.getObject();
+            if (p == null) p = "";
             if (template.isAutoEscapePlaceholder(iri)) {
                 sv = Utils.urlEncode(sv);
             }
diff --git a/src/main/java/com/knowledgepixels/nanodash/component/PublishForm.java b/src/main/java/com/knowledgepixels/nanodash/component/PublishForm.java
index b3c72274..666f4279 100644
--- a/src/main/java/com/knowledgepixels/nanodash/component/PublishForm.java
+++ b/src/main/java/com/knowledgepixels/nanodash/component/PublishForm.java
@@ -130,6 +130,9 @@ public record TemplateError(String part, String message) implements Serializable
     private final Map<String, TemplateContext> pubInfoContextMap = new HashMap<>();
     private final List<TemplateContext> requiredPubInfoContexts = new ArrayList<>();
     private String targetNamespace;
+    // The space / maintained resource / user this form was reached under, which
+    // space-/namespace-dependent template prefixes resolve against (see DynamicPrefix):
+    private final String navigationContextId;
     private final Class<? extends WebPage> confirmPageClass;
 
     /**
@@ -147,6 +150,7 @@ public PublishForm(String id, final PageParameters pageParams, Class<? extends W
         super(id);
         setOutputMarkupId(true);
         this.confirmPageClass = confirmPageClass;
+        this.navigationContextId = NavigationContext.getContextId(pageParams);
 
         WebMarkupContainer linkMessageItem = new WebMarkupContainer("link-message-item");
         if (pageParams.get("link-message").isNull()) {
@@ -219,7 +223,7 @@ public PublishForm(String id, final PageParameters pageParams, Class<? extends W
         String targetNamespaceLabel = targetNamespace + "...";
         targetNamespace = targetNamespace + "~~~ARTIFACTCODE~~~/";
 
-        assertionContext = new TemplateContext(ContextType.ASSERTION, templateId, "statement", targetNamespace);
+        assertionContext = newContext(ContextType.ASSERTION, templateId, "statement");
         assertionContext.setFillMode(fillMode);
         final String prTemplateId;
         if (pageParams.get("prtemplate").toString() != null) {
@@ -237,10 +241,10 @@ public PublishForm(String id, final PageParameters pageParams, Class<? extends W
                 prTemplateId = DEFAULT_PROV_TEMPLATE;
             }
         }
-        provenanceContext = new TemplateContext(ContextType.PROVENANCE, prTemplateId, "pr-statement", targetNamespace);
+        provenanceContext = newContext(ContextType.PROVENANCE, prTemplateId, "pr-statement");
         for (String t : fixedPubInfoTemplates) {
             // TODO consistently check for latest versions of templates here and below:
-            TemplateContext c = new TemplateContext(ContextType.PUBINFO, t, "pi-statement", targetNamespace);
+            TemplateContext c = newContext(ContextType.PUBINFO, t, "pi-statement");
             pubInfoContexts.add(c);
             pubInfoContextMap.put(c.getTemplate().getId(), c);
             requiredPubInfoContexts.add(c);
@@ -252,13 +256,13 @@ public PublishForm(String id, final PageParameters pageParams, Class<? extends W
             }
         }
         if (fillMode == FillMode.SUPERSEDE) {
-            TemplateContext c = new TemplateContext(ContextType.PUBINFO, supersedesPubInfoTemplateId, "pi-statement", targetNamespace);
+            TemplateContext c = newContext(ContextType.PUBINFO, supersedesPubInfoTemplateId, "pi-statement");
             pubInfoContexts.add(c);
             pubInfoContextMap.put(supersedesPubInfoTemplateId, c);
             //requiredPubInfoContexts.add(c);
             c.setParam("np", fillNp.getUri().stringValue());
         } else if (fillMode == FillMode.DERIVE || fillMode == FillMode.OVERRIDE) {
-            TemplateContext c = new TemplateContext(ContextType.PUBINFO, derivesFromPubInfoTemplateId, "pi-statement", targetNamespace);
+            TemplateContext c = newContext(ContextType.PUBINFO, derivesFromPubInfoTemplateId, "pi-statement");
             pubInfoContexts.add(c);
             pubInfoContextMap.put(derivesFromPubInfoTemplateId, c);
             c.setParam("np", fillNp.getUri().stringValue());
@@ -268,7 +272,7 @@ public PublishForm(String id, final PageParameters pageParams, Class<? extends W
             if (pubInfoContextMap.containsKey(r.stringValue()) || pubInfoContextMap.containsKey(latestId)) {
                 continue;
             }
-            TemplateContext c = new TemplateContext(ContextType.PUBINFO, r.stringValue(), "pi-statement", targetNamespace);
+            TemplateContext c = newContext(ContextType.PUBINFO, r.stringValue(), "pi-statement");
             pubInfoContexts.add(c);
             pubInfoContextMap.put(c.getTemplateId(), c);
             requiredPubInfoContexts.add(c);
@@ -735,7 +739,7 @@ protected void onUpdate(AjaxRequestTarget target) {
                     o = provenanceContext.getTemplate().getId();
                     prTemplateModel.setObject(o);
                 }
-                provenanceContext = new TemplateContext(ContextType.PROVENANCE, prTemplateModel.getObject(), "pr-statement", targetNamespace);
+                provenanceContext = newContext(ContextType.PROVENANCE, prTemplateModel.getObject(), "pr-statement");
                 provenanceContext.initStatements();
                 refreshProvenance(target);
                 provenanceContext.finalizeStatements();
@@ -865,7 +869,7 @@ protected void onUpdate(AjaxRequestTarget target) {
                     return;
                 }
                 String id = newPiTemplateModel.getObject();
-                TemplateContext c = new TemplateContext(ContextType.PUBINFO, id, "pi-statement", targetNamespace);
+                TemplateContext c = newContext(ContextType.PUBINFO, id, "pi-statement");
                 c.initStatements();
                 pubInfoContexts.add(c);
                 newPiTemplateModel.setObject(null);
@@ -1002,12 +1006,22 @@ protected void populateItem(ListItem<StatementItem> item) {
         }
     }
 
+    /**
+     * Creates a template context for this form, carrying the form's target namespace and
+     * navigation context (the latter resolves space-/namespace-dependent prefixes).
+     */
+    private TemplateContext newContext(ContextType contextType, String templateId, String componentId) {
+        TemplateContext context = new TemplateContext(contextType, templateId, componentId, targetNamespace);
+        context.setNavigationContextId(navigationContextId);
+        return context;
+    }
+
     private TemplateContext createPubInfoContext(String piTemplateId) {
         TemplateContext c;
         if (pubInfoContextMap.containsKey(piTemplateId)) {
             c = pubInfoContextMap.get(piTemplateId);
         } else {
-            c = new TemplateContext(ContextType.PUBINFO, piTemplateId, "pi-statement", targetNamespace);
+            c = newContext(ContextType.PUBINFO, piTemplateId, "pi-statement");
             pubInfoContextMap.put(piTemplateId, c);
             pubInfoContexts.add(c);
         }
@@ -1114,7 +1128,7 @@ private String getNanopubLabel(NanopubCreator npCreator) {
                 try {
                     // TODO Fix this. It doesn't work for placeholders with auto-encode placeholders, etc.
                     //      Not sure we need labels for these, but this code should be improved anyway.
-                    String prefix = assertionContext.getTemplate().getPrefix(placeholderIri);
+                    String prefix = assertionContext.getPrefix(placeholderIri);
                     if (prefix != null) {
                         placeholderValue = prefix + placeholderValue;
                     }
diff --git a/src/main/java/com/knowledgepixels/nanodash/component/ReadonlyItem.java b/src/main/java/com/knowledgepixels/nanodash/component/ReadonlyItem.java
index be1b0dc9..9d9f7629 100644
--- a/src/main/java/com/knowledgepixels/nanodash/component/ReadonlyItem.java
+++ b/src/main/java/com/knowledgepixels/nanodash/component/ReadonlyItem.java
@@ -101,7 +101,7 @@ public ReadonlyItem(String id, String parentId, final IRI iriP, IRI statementPar
             foafNameMap = Utils.getFoafNameMap(context.getExistingNanopub());
         }
 
-        prefix = template.getPrefix(iri);
+        prefix = context.getPrefix(iri);
         if (prefix == null) prefix = "";
         if (template.isRestrictedChoicePlaceholder(iri)) {
             restrictedChoice = new RestrictedChoice(iri, context);
diff --git a/src/main/java/com/knowledgepixels/nanodash/repository/MaintainedResourceRepository.java b/src/main/java/com/knowledgepixels/nanodash/repository/MaintainedResourceRepository.java
index 9c399bbe..30c417a9 100644
--- a/src/main/java/com/knowledgepixels/nanodash/repository/MaintainedResourceRepository.java
+++ b/src/main/java/com/knowledgepixels/nanodash/repository/MaintainedResourceRepository.java
@@ -143,6 +143,15 @@ public MaintainedResource findByNamespace(String namespace) {
         return current().resourcesByNamespace.get(namespace);
     }
 
+    /**
+     * Get all known maintained resources.
+     *
+     * @return The list of maintained resources, in no particular order.
+     */
+    public List<MaintainedResource> findAll() {
+        return new ArrayList<>(current().resourcesById.values());
+    }
+
     /**
      * Find the maintained resources belonging to a given space.
      *
diff --git a/src/main/java/com/knowledgepixels/nanodash/repository/SpaceRepository.java b/src/main/java/com/knowledgepixels/nanodash/repository/SpaceRepository.java
index 1845b2ff..edbbd45e 100644
--- a/src/main/java/com/knowledgepixels/nanodash/repository/SpaceRepository.java
+++ b/src/main/java/com/knowledgepixels/nanodash/repository/SpaceRepository.java
@@ -200,6 +200,15 @@ public Space findById(String id) {
         return current().spacesById.get(id);
     }
 
+    /**
+     * Get all known spaces, one representative per space IRI (see {@link #reduceByRef}).
+     *
+     * @return The list of spaces, in no particular order.
+     */
+    public List<Space> findAll() {
+        return new ArrayList<>(current().spacesById.values());
+    }
+
     /**
      * Get a space by one of its alternative IDs.
      *
diff --git a/src/main/java/com/knowledgepixels/nanodash/template/TemplateContext.java b/src/main/java/com/knowledgepixels/nanodash/template/TemplateContext.java
index 2e3aa18c..39ef9b5b 100644
--- a/src/main/java/com/knowledgepixels/nanodash/template/TemplateContext.java
+++ b/src/main/java/com/knowledgepixels/nanodash/template/TemplateContext.java
@@ -1,5 +1,6 @@
 package com.knowledgepixels.nanodash.template;
 
+import com.knowledgepixels.nanodash.DynamicPrefix;
 import com.knowledgepixels.nanodash.LocalUri;
 import com.knowledgepixels.nanodash.NanodashSession;
 import com.knowledgepixels.nanodash.Utils;
@@ -49,6 +50,7 @@ public class TemplateContext implements Serializable {
     private Nanopub fillSource;
     private Map<IRI, String> labels;
     private FillMode fillMode = null;
+    private String navigationContextId;
 
     /**
      * Constructor for creating a new template context for filling a template.
@@ -276,6 +278,106 @@ public static IRI getLanguageModelKey(IRI iri) {
         return vf.createIRI(iri.stringValue() + LANGUAGE_SUFFIX);
     }
 
+    /**
+     * Suffix of the URL parameter that pre-fills the chosen base of a
+     * space-/namespace-dependent prefix, appended to a placeholder's postfix
+     * (e.g. {@code param_resource__prefix}).
+     */
+    public static final String PREFIX_SUFFIX = "__prefix";
+
+    /**
+     * Returns the component-model key for the base chosen for the given
+     * space-/namespace-dependent prefix placeholder. The key is derived from the
+     * <em>token</em>, not from the placeholder, so every field whose prefix depends on the
+     * same thing shares one model: picking a space in one picker sets it for all of them
+     * (and for every repetition), which is what the shared-model AJAX refresh in the form
+     * items keys on.
+     *
+     * @param token the token, as returned by {@link DynamicPrefix#getToken(String)}
+     * @return the derived key for the prefix-base model
+     */
+    public static IRI getPrefixModelKey(String token) {
+        return vf.createIRI(LocalUri.PREFIX + "prefix-base/" + token.replace("~", ""));
+    }
+
+    /**
+     * Sets the navigation context (the {@code context} URL parameter of the page this
+     * context is filled on), which determines the space or maintained resource that
+     * space-/namespace-dependent prefixes resolve against.
+     *
+     * @param navigationContextId the context resource id, or null if the page has none
+     */
+    public void setNavigationContextId(String navigationContextId) {
+        this.navigationContextId = navigationContextId;
+    }
+
+    /**
+     * Returns the navigation context id this context resolves space-/namespace-dependent
+     * prefixes against.
+     *
+     * @return the context resource id, or null if none is set
+     */
+    public String getNavigationContextId() {
+        return navigationContextId;
+    }
+
+    /**
+     * Returns the prefix of the given placeholder, with a space-/namespace-dependent
+     * placeholder ({@link DynamicPrefix#SPACE_TOKEN}, {@link DynamicPrefix#NAMESPACE_TOKEN})
+     * substituted by the base the navigation context — or the user's pick — determines.
+     * Use this instead of {@link Template#getPrefix(IRI)} wherever the prefix is shown to
+     * the user or used to build a value.
+     *
+     * @param iri the placeholder IRI
+     * @return the resolved prefix; null if the template declares none, and also null if it
+     * declares a dynamic one that isn't resolved yet (tell the two apart with
+     * {@link #hasUnresolvedPrefix(IRI)})
+     */
+    public String getPrefix(IRI iri) {
+        String rawPrefix = template.getPrefix(iri);
+        String token = DynamicPrefix.getToken(rawPrefix);
+        if (token == null) return rawPrefix;
+        String base = resolvePrefixBase(token);
+        if (base == null) return null;
+        return rawPrefix.replace(token, base);
+    }
+
+    /**
+     * Whether the given placeholder declares a space-/namespace-dependent prefix (resolved
+     * or not). Such a prefix takes precedence over the target namespace a
+     * {@code nt:LocalResource} would otherwise be minted under: declaring one is exactly
+     * how a template says "mint this new resource under the space / maintained resource
+     * instead of under the nanopublication".
+     *
+     * @param iri the placeholder IRI
+     * @return true if the prefix is space-/namespace-dependent
+     */
+    public boolean hasDynamicPrefix(IRI iri) {
+        return DynamicPrefix.getToken(template.getPrefix(iri)) != null;
+    }
+
+    /**
+     * Whether the given placeholder's prefix is space-/namespace-dependent and its base is
+     * not (yet) determined, i.e. the page carries no usable navigation context and the user
+     * hasn't picked one.
+     *
+     * @param iri the placeholder IRI
+     * @return true if the prefix is dynamic and unresolved
+     */
+    public boolean hasUnresolvedPrefix(IRI iri) {
+        String token = DynamicPrefix.getToken(template.getPrefix(iri));
+        return token != null && resolvePrefixBase(token) == null;
+    }
+
+    private String resolvePrefixBase(String token) {
+        String base = DynamicPrefix.resolveFromContext(token, navigationContextId);
+        if (base != null && !base.isEmpty()) return base;
+        IModel<?> model = componentModels.get(getPrefixModelKey(token));
+        Object chosen = (model == null) ? null : model.getObject();
+        if (chosen == null || chosen.toString().isEmpty()) return null;
+        return chosen.toString();
+    }
+
     /**
      * Returns the introduced IRIs in this context.
      *
@@ -368,33 +470,62 @@ public Value processValue(Value value) {
         if (template.isRestrictedChoicePlaceholder(iri)) {
             String tfObject = (String) tfObjectGeneric;
             if (tf != null && tfObject != null && !tfObject.isEmpty()) {
-                String prefix = template.getPrefix(iri);
+                String prefix = getPrefix(iri);
+                boolean unresolvedPrefix = prefix == null && hasUnresolvedPrefix(iri);
                 if (prefix == null) prefix = "";
-                if (template.isLocalResource(iri)) prefix = targetNamespace;
-                if (tfObject.matches("https?://.+")) prefix = "";
-                String v = prefix + tf.getObject();
-                if (v.matches("[^:# ]+")) v = targetNamespace + v;
-                if (v.matches("https?://.*")) {
-                    processedValue = vf.createIRI(v);
-                } else {
-                    processedValue = vf.createLiteral(tfObject);
+                // A dynamic prefix is how a template asks for its new resource to be minted
+                // under the space / maintained resource rather than under the nanopublication,
+                // so it wins over the local-resource default (issue #571).
+                if (template.isLocalResource(iri) && !hasDynamicPrefix(iri)) {
+                    prefix = targetNamespace;
+                    unresolvedPrefix = false;
+                }
+                if (tfObject.matches("https?://.+")) {
+                    prefix = "";
+                    unresolvedPrefix = false;
+                }
+                // An unresolved space-/namespace-dependent prefix would mint the resource
+                // under the wrong namespace; leave the value unset instead. Form validation
+                // blocks publishing in this state.
+                if (!unresolvedPrefix) {
+                    String v = prefix + tf.getObject();
+                    if (v.matches("[^:# ]+")) v = targetNamespace + v;
+                    if (v.matches("https?://.*")) {
+                        processedValue = vf.createIRI(v);
+                    } else {
+                        processedValue = vf.createLiteral(tfObject);
+                    }
                 }
             }
         } else if (template.isUriPlaceholder(iri)) {
             String tfObject = (String) tfObjectGeneric;
             if (tf != null && tfObject != null && !tfObject.isEmpty()) {
-                String prefix = template.getPrefix(iri);
+                String prefix = getPrefix(iri);
+                boolean unresolvedPrefix = prefix == null && hasUnresolvedPrefix(iri);
                 if (prefix == null) prefix = "";
-                if (template.isLocalResource(iri)) prefix = targetNamespace;
+                // A dynamic prefix is how a template asks for its new resource to be minted
+                // under the space / maintained resource rather than under the nanopublication,
+                // so it wins over the local-resource default (issue #571).
+                if (template.isLocalResource(iri) && !hasDynamicPrefix(iri)) {
+                    prefix = targetNamespace;
+                    unresolvedPrefix = false;
+                }
                 String v;
                 if (template.isAutoEscapePlaceholder(iri)) {
                     v = prefix + Utils.urlEncode(tf.getObject());
                 } else {
-                    if (tfObject.matches("https?://.+")) prefix = "";
+                    if (tfObject.matches("https?://.+")) {
+                        prefix = "";
+                        unresolvedPrefix = false;
+                    }
                     v = prefix + tf.getObject();
                 }
-                if (v.matches("[^:# ]+")) v = targetNamespace + v;
-                processedValue = vf.createIRI(v);
+                // See the restricted-choice branch above: an unresolved dynamic prefix
+                // leaves the value unset rather than minting a wrongly-namespaced IRI.
+                if (!unresolvedPrefix) {
+                    if (v.matches("[^:# ]+")) v = targetNamespace + v;
+                    processedValue = vf.createIRI(v);
+                }
             }
         } else if (template.isLocalResource(iri)) {
             String tfObject = (String) tfObjectGeneric;
diff --git a/src/test/java/com/knowledgepixels/nanodash/DynamicPrefixTest.java b/src/test/java/com/knowledgepixels/nanodash/DynamicPrefixTest.java
new file mode 100644
index 00000000..57a6566f
--- /dev/null
+++ b/src/test/java/com/knowledgepixels/nanodash/DynamicPrefixTest.java
@@ -0,0 +1,46 @@
+package com.knowledgepixels.nanodash;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+/**
+ * Token detection for the space-/namespace-dependent prefixes of issue #571
+ * (docs/space-namespace-prefixes.md).
+ */
+class DynamicPrefixTest {
+
+    @Test
+    void spaceTokenIsDetected() {
+        assertEquals(DynamicPrefix.SPACE_TOKEN, DynamicPrefix.getToken("~~SPACE~~/"));
+        assertEquals(DynamicPrefix.SPACE_TOKEN, DynamicPrefix.getToken("~~SPACE~~/r/"));
+    }
+
+    @Test
+    void namespaceTokenIsDetected() {
+        assertEquals(DynamicPrefix.NAMESPACE_TOKEN, DynamicPrefix.getToken("~~NAMESPACE~~"));
+    }
+
+    @Test
+    void staticPrefixHasNoToken() {
+        assertNull(DynamicPrefix.getToken("https://example.org/"));
+        assertNull(DynamicPrefix.getToken(""));
+        assertNull(DynamicPrefix.getToken(null));
+        // The unrelated artifact-code placeholder must not be mistaken for one of ours:
+        assertNull(DynamicPrefix.getToken("https://w3id.org/np/~~ARTIFACTCODE~~/"));
+    }
+
+    @Test
+    void withoutContextNothingResolves() {
+        assertNull(DynamicPrefix.resolveFromContext(DynamicPrefix.SPACE_TOKEN, null));
+        assertNull(DynamicPrefix.resolveFromContext(DynamicPrefix.NAMESPACE_TOKEN, ""));
+    }
+
+    @Test
+    void selectionLabelsNameWhatIsPicked() {
+        assertEquals("space", DynamicPrefix.getSelectionLabel(DynamicPrefix.SPACE_TOKEN));
+        assertEquals("resource", DynamicPrefix.getSelectionLabel(DynamicPrefix.NAMESPACE_TOKEN));
+    }
+
+}
diff --git a/src/test/java/com/knowledgepixels/nanodash/component/IriTextfieldPrefixItemTest.java b/src/test/java/com/knowledgepixels/nanodash/component/IriTextfieldPrefixItemTest.java
new file mode 100644
index 00000000..1c3eaa57
--- /dev/null
+++ b/src/test/java/com/knowledgepixels/nanodash/component/IriTextfieldPrefixItemTest.java
@@ -0,0 +1,314 @@
+package com.knowledgepixels.nanodash.component;
+
+import com.knowledgepixels.nanodash.DynamicPrefix;
+import com.knowledgepixels.nanodash.NavigationContext;
+import com.knowledgepixels.nanodash.WicketApplication;
+import com.knowledgepixels.nanodash.domain.Space;
+import com.knowledgepixels.nanodash.template.ContextType;
+import com.knowledgepixels.nanodash.template.Template;
+import com.knowledgepixels.nanodash.template.TemplateContext;
+import com.knowledgepixels.nanodash.template.TemplateData;
+import com.knowledgepixels.nanodash.template.TemplateTestUtil;
+import org.apache.wicket.Component;
+import org.apache.wicket.util.tester.WicketTester;
+import org.eclipse.rdf4j.model.IRI;
+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.NanopubCreator;
+import org.nanopub.vocabulary.NTEMPLATE;
+import org.wicketstuff.select2.Select2Choice;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
+
+/**
+ * Component-level tests for the picker that supplies the base of a
+ * space-/namespace-dependent prefix when the navigation context determines none
+ * (issue #571, docs/space-namespace-prefixes.md).
+ */
+public class IriTextfieldPrefixItemTest {
+
+    private static final ValueFactory vf = SimpleValueFactory.getInstance();
+
+    private static final String NP_URI = "https://w3id.org/np/RAAbCdEfGhIjKlMnOpQrStUvWxYz0123456789-_AbCdE";
+    private static final IRI RESOURCE = vf.createIRI(NP_URI + "/resource");
+    private static final IRI OTHER = vf.createIRI(NP_URI + "/other");
+    private static final String SPACE_IRI = "https://w3id.org/space/foo/bar";
+
+    private WicketTester tester;
+    private MockedStatic<TemplateData> templateDataMockedStatic;
+    private MockedStatic<NavigationContext> navigationContextMockedStatic;
+
+    @BeforeEach
+    void setUp() {
+        tester = new WicketTester(new WicketApplication());
+        templateDataMockedStatic = mockStatic(TemplateData.class);
+        navigationContextMockedStatic = mockStatic(NavigationContext.class, CALLS_REAL_METHODS);
+    }
+
+    @AfterEach
+    void tearDown() {
+        templateDataMockedStatic.close();
+        navigationContextMockedStatic.close();
+    }
+
+    /**
+     * Builds a one-statement template whose object is a URI placeholder with the given
+     * prefix, and returns an uninitialized context for it; call setParam before
+     * initStatements.
+     */
+    private TemplateContext contextFor(String prefix) 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 st1 = vf.createIRI(NP_URI + "/st1");
+        creator.addAssertionStatement(templateNode, RDF.TYPE, NTEMPLATE.ASSERTION_TEMPLATE);
+        creator.addAssertionStatement(templateNode, RDFS.LABEL, vf.createLiteral("Prefix component test template"));
+        creator.addAssertionStatement(templateNode, NTEMPLATE.HAS_STATEMENT, st1);
+        creator.addAssertionStatement(st1, RDF.SUBJECT, vf.createIRI("http://example.com/subject"));
+        creator.addAssertionStatement(st1, RDF.PREDICATE, vf.createIRI("http://example.com/hasPart"));
+        creator.addAssertionStatement(st1, RDF.OBJECT, RESOURCE);
+        creator.addAssertionStatement(RESOURCE, RDF.TYPE, NTEMPLATE.URI_PLACEHOLDER);
+        creator.addAssertionStatement(RESOURCE, NTEMPLATE.HAS_PREFIX, vf.createLiteral(prefix));
+        creator.addAssertionStatement(RESOURCE, NTEMPLATE.HAS_PREFIX_LABEL, vf.createLiteral("Class"));
+        creator.addAssertionStatement(RESOURCE, RDFS.LABEL, vf.createLiteral("resource"));
+        Template template = TemplateTestUtil.parseTemplate(creator.finalizeNanopub());
+
+        TemplateData templateDataMock = mock(TemplateData.class);
+        templateDataMockedStatic.when(TemplateData::get).thenReturn(templateDataMock);
+        when(templateDataMock.getTemplate(NP_URI)).thenReturn(template);
+
+        return new TemplateContext(ContextType.ASSERTION, NP_URI, "statement", (String) null);
+    }
+
+    private void withSpaceContext(String contextId) {
+        Space space = mock(Space.class);
+        when(space.getId()).thenReturn(SPACE_IRI);
+        when(space.getSpace()).thenReturn(space);
+        navigationContextMockedStatic.when(() -> NavigationContext.resolve(contextId)).thenReturn(space);
+    }
+
+    @Test
+    void prefixChoiceIsAddedWhenTheContextDeterminesNoBase() throws Exception {
+        TemplateContext context = contextFor("~~SPACE~~/r/");
+        context.initStatements();
+        assertEquals(2, context.getComponents().size(), "text field and prefix choice must both be registered");
+        assertTrue(context.getComponentModels().containsKey(TemplateContext.getPrefixModelKey(DynamicPrefix.SPACE_TOKEN)));
+        assertTrue(context.hasUnresolvedPrefix(RESOURCE));
+    }
+
+    @Test
+    void noPrefixChoiceWhenTheContextDeterminesTheBase() throws Exception {
+        withSpaceContext(SPACE_IRI);
+        TemplateContext context = contextFor("~~SPACE~~/r/");
+        context.setNavigationContextId(SPACE_IRI);
+        context.initStatements();
+        assertEquals(1, context.getComponents().size(), "a context-resolved prefix needs no picker");
+        assertFalse(context.getComponentModels().containsKey(TemplateContext.getPrefixModelKey(DynamicPrefix.SPACE_TOKEN)));
+        assertEquals(SPACE_IRI + "/r/", context.getPrefix(RESOURCE));
+    }
+
+    @Test
+    void noPrefixChoiceForAStaticPrefix() throws Exception {
+        TemplateContext context = contextFor("https://example.org/");
+        context.initStatements();
+        assertEquals(1, context.getComponents().size());
+        assertFalse(context.getComponentModels().containsKey(TemplateContext.getPrefixModelKey(DynamicPrefix.SPACE_TOKEN)));
+    }
+
+    /**
+     * A field under a dynamic prefix holds only the name below that prefix, so a
+     * "param_&lt;postfix&gt;" for it is ignored — otherwise a full IRI passed that way would
+     * land in the field and bypass the prefix entirely. Both with and without a resolving
+     * navigation context, so a bare "~~SPACE~~" behaves like "~~SPACE~~/r/" either way.
+     */
+    @Test
+    void valueParamDoesNotPrefillAFieldUnderADynamicPrefix() throws Exception {
+        withSpaceContext(SPACE_IRI);
+        TemplateContext context = contextFor("~~SPACE~~");
+        context.setNavigationContextId(SPACE_IRI);
+        context.setParam("resource", SPACE_IRI);
+        context.initStatements();
+        assertEquals("", context.getComponentModels().get(RESOURCE).getObject());
+        assertEquals(SPACE_IRI, context.getPrefix(RESOURCE));
+    }
+
+    @Test
+    void valueParamDoesNotPrefillAFieldUnderAnUnresolvedDynamicPrefix() throws Exception {
+        TemplateContext context = contextFor("~~SPACE~~/r/");
+        context.setParam("resource", "https://w3id.org/space/elsewhere/r/thing");
+        context.initStatements();
+        assertEquals("", context.getComponentModels().get(RESOURCE).getObject());
+    }
+
+    @Test
+    void valueParamStillPrefillsAFieldUnderAStaticPrefix() throws Exception {
+        TemplateContext context = contextFor("https://example.org/");
+        context.setParam("resource", "thing");
+        context.initStatements();
+        assertEquals("thing", context.getComponentModels().get(RESOURCE).getObject());
+    }
+
+    @Test
+    void prefixParamPrefillsTheChoice() throws Exception {
+        TemplateContext context = contextFor("~~SPACE~~/r/");
+        context.setParam("resource__prefix", "https://w3id.org/space/other");
+        context.initStatements();
+        assertEquals("https://w3id.org/space/other/r/", context.getPrefix(RESOURCE));
+        assertFalse(context.hasUnresolvedPrefix(RESOURCE));
+    }
+
+    /**
+     * Builds a template with two URI placeholders carrying the given prefixes, and returns
+     * an uninitialized context for it.
+     */
+    private TemplateContext contextForTwo(String prefixA, String prefixB) 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();
+        creator.addAssertionStatement(templateNode, RDF.TYPE, NTEMPLATE.ASSERTION_TEMPLATE);
+        creator.addAssertionStatement(templateNode, RDFS.LABEL, vf.createLiteral("Two dynamic prefixes"));
+        IRI subject = vf.createIRI("http://example.com/subject");
+        int i = 0;
+        for (IRI placeholder : new IRI[]{RESOURCE, OTHER}) {
+            IRI st = vf.createIRI(NP_URI + "/st" + (++i));
+            creator.addAssertionStatement(templateNode, NTEMPLATE.HAS_STATEMENT, st);
+            creator.addAssertionStatement(st, RDF.SUBJECT, subject);
+            creator.addAssertionStatement(st, RDF.PREDICATE, vf.createIRI("http://example.com/p" + i));
+            creator.addAssertionStatement(st, RDF.OBJECT, placeholder);
+            creator.addAssertionStatement(placeholder, RDF.TYPE, NTEMPLATE.URI_PLACEHOLDER);
+            creator.addAssertionStatement(placeholder, NTEMPLATE.HAS_PREFIX, vf.createLiteral(i == 1 ? prefixA : prefixB));
+            creator.addAssertionStatement(placeholder, RDFS.LABEL, vf.createLiteral("placeholder " + i));
+        }
+        Template template = TemplateTestUtil.parseTemplate(creator.finalizeNanopub());
+
+        TemplateData templateDataMock = mock(TemplateData.class);
+        templateDataMockedStatic.when(TemplateData::get).thenReturn(templateDataMock);
+        when(templateDataMock.getTemplate(NP_URI)).thenReturn(template);
+
+        return new TemplateContext(ContextType.ASSERTION, NP_URI, "statement", (String) null);
+    }
+
+    @Test
+    void pickersOnTheSameTokenShareOneModel() throws Exception {
+        // Different suffixes, same token: one shared base, each field keeping its own suffix.
+        TemplateContext context = contextForTwo("~~SPACE~~/r/", "~~SPACE~~/");
+        context.initStatements();
+        List<Select2Choice<?>> pickers = pickersIn(context);
+        assertEquals(2, pickers.size(), "both fields must get a picker");
+        assertSame(pickers.get(0).getDefaultModel(), pickers.get(1).getDefaultModel(),
+                "pickers on the same token must share one model, so the shared-model AJAX refresh reaches both");
+
+        // Choosing in one picker resolves the prefix of both fields.
+        pickers.get(0).setDefaultModelObject("https://w3id.org/space/other");
+        assertEquals("https://w3id.org/space/other/r/", context.getPrefix(RESOURCE));
+        assertEquals("https://w3id.org/space/other/", context.getPrefix(OTHER));
+        assertFalse(context.hasUnresolvedPrefix(RESOURCE));
+        assertFalse(context.hasUnresolvedPrefix(OTHER));
+    }
+
+    @Test
+    void pickersOnDifferentTokensKeepSeparateModels() throws Exception {
+        // A space and a maintained-resource namespace are different things picked from
+        // different lists, so they must not share a value.
+        TemplateContext context = contextForTwo("~~SPACE~~/r/", "~~NAMESPACE~~");
+        context.initStatements();
+        List<Select2Choice<?>> pickers = pickersIn(context);
+        assertEquals(2, pickers.size());
+        assertNotSame(pickers.get(0).getDefaultModel(), pickers.get(1).getDefaultModel());
+
+        pickers.get(0).setDefaultModelObject("https://w3id.org/space/other");
+        assertEquals("https://w3id.org/space/other/r/", context.getPrefix(RESOURCE));
+        assertNull(context.getPrefix(OTHER), "the namespace picker must be unaffected");
+        assertTrue(context.hasUnresolvedPrefix(OTHER));
+    }
+
+    private static List<Select2Choice<?>> pickersIn(TemplateContext context) {
+        List<Select2Choice<?>> pickers = new ArrayList<>();
+        for (Component c : context.getComponents()) {
+            if (c instanceof Select2Choice<?> choice) pickers.add(choice);
+        }
+        return pickers;
+    }
+
+    @Test
+    void itemRendersWithThePicker() throws Exception {
+        TemplateContext context = contextFor("~~SPACE~~/r/");
+        context.initStatements();
+        tester.startComponentInPage(new IriTextfieldItem("value", "obj", RESOURCE, true, context));
+        tester.assertComponent("value:prefixchoice", Select2Choice.class);
+    }
+
+    @Test
+    void itemRendersWithoutThePicker() throws Exception {
+        TemplateContext context = contextFor("https://example.org/");
+        context.initStatements();
+        tester.startComponentInPage(new IriTextfieldItem("value", "obj", RESOURCE, true, context));
+        tester.assertInvisible("value:prefixchoice");
+    }
+
+    /**
+     * The picker already names what is being chosen, so the template's static prefix label
+     * would only duplicate it; it is shown only when no picker is.
+     */
+    @Test
+    void prefixLabelIsHiddenWhenThePickerIsShown() throws Exception {
+        TemplateContext context = contextFor("~~SPACE~~/r/");
+        context.initStatements();
+        tester.startComponentInPage(new IriTextfieldItem("value", "obj", RESOURCE, true, context));
+        tester.assertComponent("value:prefixchoice", Select2Choice.class);
+        tester.assertInvisible("value:prefix");
+    }
+
+    @Test
+    void prefixLabelIsShownWhenTheContextResolvesTheBase() throws Exception {
+        withSpaceContext(SPACE_IRI);
+        TemplateContext context = contextFor("~~SPACE~~/r/");
+        context.setNavigationContextId(SPACE_IRI);
+        context.initStatements();
+        tester.startComponentInPage(new IriTextfieldItem("value", "obj", RESOURCE, true, context));
+        tester.assertInvisible("value:prefixchoice");
+        tester.assertVisible("value:prefix");
+        tester.assertLabel("value:prefix", "Class");
+    }
+
+    @Test
+    void prefixLabelIsShownForAStaticPrefix() throws Exception {
+        TemplateContext context = contextFor("https://example.org/");
+        context.initStatements();
+        tester.startComponentInPage(new IriTextfieldItem("value", "obj", RESOURCE, true, context));
+        tester.assertVisible("value:prefix");
+        tester.assertLabel("value:prefix", "Class");
+    }
+
+    @Test
+    void removeFromContextDeregistersBothComponents() throws Exception {
+        TemplateContext context = contextFor("~~SPACE~~/r/");
+        context.initStatements();
+        assertEquals(2, context.getComponents().size());
+        IriTextfieldItem extra = new IriTextfieldItem("value", "obj", RESOURCE, true, context);
+        assertEquals(4, context.getComponents().size());
+        extra.removeFromContext();
+        assertEquals(2, context.getComponents().size());
+    }
+
+}
diff --git a/src/test/java/com/knowledgepixels/nanodash/template/DynamicPrefixPublishTest.java b/src/test/java/com/knowledgepixels/nanodash/template/DynamicPrefixPublishTest.java
new file mode 100644
index 00000000..b84f438d
--- /dev/null
+++ b/src/test/java/com/knowledgepixels/nanodash/template/DynamicPrefixPublishTest.java
@@ -0,0 +1,285 @@
+package com.knowledgepixels.nanodash.template;
+
+import com.knowledgepixels.nanodash.DynamicPrefix;
+import com.knowledgepixels.nanodash.NavigationContext;
+import com.knowledgepixels.nanodash.WicketApplication;
+import com.knowledgepixels.nanodash.domain.MaintainedResource;
+import com.knowledgepixels.nanodash.domain.Space;
+import org.apache.wicket.model.IModel;
+import org.apache.wicket.model.Model;
+import org.apache.wicket.util.tester.WicketTester;
+import org.eclipse.rdf4j.model.IRI;
+import org.eclipse.rdf4j.model.Statement;
+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.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
+
+/**
+ * Publish-path tests for space-/namespace-dependent {@code nt:hasPrefix} values
+ * (issue #571, docs/space-namespace-prefixes.md): the prefix is resolved against the
+ * navigation context, or against the base the user picked when the context determines
+ * none; an unresolved prefix never mints a wrongly-namespaced IRI.
+ */
+public class DynamicPrefixPublishTest {
+
+    private static final ValueFactory vf = SimpleValueFactory.getInstance();
+
+    private static final String NP_URI = "https://w3id.org/np/RAAbCdEfGhIjKlMnOpQrStUvWxYz0123456789-_AbCdE";
+    private static final IRI ST1 = vf.createIRI(NP_URI + "/st1");
+    private static final IRI RESOURCE = vf.createIRI(NP_URI + "/resource");
+    private static final IRI SUBJECT = vf.createIRI("http://example.com/subject");
+    private static final IRI HAS_PART = vf.createIRI("http://example.com/hasPart");
+
+    private static final String SPACE_IRI = "https://w3id.org/space/foo/bar";
+
+    private MockedStatic<TemplateData> templateDataMockedStatic;
+    private MockedStatic<NavigationContext> navigationContextMockedStatic;
+
+    @BeforeEach
+    void setUp() {
+        new WicketTester(new WicketApplication());
+        templateDataMockedStatic = mockStatic(TemplateData.class);
+        // Only resolve() is stubbed; the rest of NavigationContext stays real, as the
+        // rendered items use its link-fallback behaviors.
+        navigationContextMockedStatic = mockStatic(NavigationContext.class, CALLS_REAL_METHODS);
+    }
+
+    @AfterEach
+    void tearDown() {
+        templateDataMockedStatic.close();
+        navigationContextMockedStatic.close();
+    }
+
+    /**
+     * Builds a template with one optional statement (subject ex:hasPart [resource]) whose
+     * object is a URI placeholder carrying the given prefix, and returns an initialized
+     * context for it, set to the given navigation context.
+     */
+    private TemplateContext contextWith(String prefix, String navigationContextId) throws Exception {
+        return contextWith(prefix, navigationContextId, false);
+    }
+
+    /**
+     * As above, but optionally declaring the placeholder a local + introduced resource, the
+     * shape real "define a new X in this space" templates use.
+     */
+    private TemplateContext contextWith(String prefix, String navigationContextId, boolean localResource) 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();
+        creator.addAssertionStatement(templateNode, RDF.TYPE, NTEMPLATE.ASSERTION_TEMPLATE);
+        creator.addAssertionStatement(templateNode, RDFS.LABEL, vf.createLiteral("Dynamic prefix test template"));
+        // Constant statement st0 keeps the assertion graph non-empty when the optional
+        // statement st1 is dropped:
+        IRI st0 = vf.createIRI(NP_URI + "/st0");
+        creator.addAssertionStatement(templateNode, NTEMPLATE.HAS_STATEMENT, st0);
+        creator.addAssertionStatement(st0, RDF.SUBJECT, SUBJECT);
+        creator.addAssertionStatement(st0, RDF.PREDICATE, RDF.TYPE);
+        creator.addAssertionStatement(st0, RDF.OBJECT, vf.createIRI("http://example.com/SomeClass"));
+        creator.addAssertionStatement(templateNode, NTEMPLATE.HAS_STATEMENT, ST1);
+        creator.addAssertionStatement(ST1, RDF.TYPE, NTEMPLATE.OPTIONAL_STATEMENT);
+        creator.addAssertionStatement(ST1, RDF.SUBJECT, SUBJECT);
+        creator.addAssertionStatement(ST1, RDF.PREDICATE, HAS_PART);
+        creator.addAssertionStatement(ST1, RDF.OBJECT, RESOURCE);
+        creator.addAssertionStatement(RESOURCE, RDF.TYPE, NTEMPLATE.URI_PLACEHOLDER);
+        if (localResource) {
+            creator.addAssertionStatement(RESOURCE, RDF.TYPE, NTEMPLATE.LOCAL_RESOURCE);
+            creator.addAssertionStatement(RESOURCE, RDF.TYPE, NTEMPLATE.INTRODUCED_RESOURCE);
+        }
+        creator.addAssertionStatement(RESOURCE, NTEMPLATE.HAS_PREFIX, vf.createLiteral(prefix));
+        creator.addAssertionStatement(RESOURCE, RDFS.LABEL, vf.createLiteral("resource"));
+        Template template = new Template(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", (String) null);
+        context.setNavigationContextId(navigationContextId);
+        context.initStatements();
+        return context;
+    }
+
+    /**
+     * Makes the given context id resolve to a space with {@link #SPACE_IRI}.
+     */
+    private void withSpaceContext(String contextId) {
+        Space space = mock(Space.class);
+        when(space.getId()).thenReturn(SPACE_IRI);
+        when(space.getSpace()).thenReturn(space);
+        navigationContextMockedStatic.when(() -> NavigationContext.resolve(contextId)).thenReturn(space);
+    }
+
+    /**
+     * Makes the given context id resolve to a maintained resource of {@link #SPACE_IRI}
+     * with the given (possibly absent) declared namespace.
+     */
+    private void withResourceContext(String contextId, String resourceIri, String namespace) {
+        Space space = mock(Space.class);
+        when(space.getId()).thenReturn(SPACE_IRI);
+        MaintainedResource resource = mock(MaintainedResource.class);
+        when(resource.getId()).thenReturn(resourceIri);
+        when(resource.getNamespace()).thenReturn(namespace);
+        when(resource.getSpace()).thenReturn(space);
+        navigationContextMockedStatic.when(() -> NavigationContext.resolve(contextId)).thenReturn(resource);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void setText(TemplateContext context, String value) {
+        ((IModel<Object>) context.getComponentModels().get(RESOURCE)).setObject(value);
+    }
+
+    private void pickPrefixBase(TemplateContext context, String rawPrefix, String base) {
+        context.getComponentModels().put(TemplateContext.getPrefixModelKey(DynamicPrefix.getToken(rawPrefix)), Model.of(base));
+    }
+
+    private Nanopub publish(TemplateContext context) throws Exception {
+        NanopubCreator creator = new NanopubCreator("http://purl.org/nanopub/temp/result/");
+        context.propagateStatements(creator);
+        creator.addProvenanceStatement(vf.createStatement(creator.getAssertionUri(), RDFS.SEEALSO, creator.getAssertionUri()));
+        creator.addPubinfoStatement(vf.createStatement(creator.getNanopubUri(), RDFS.SEEALSO, creator.getNanopubUri()));
+        return creator.finalizeNanopub();
+    }
+
+    private static Value partOf(Nanopub np) {
+        for (Statement st : np.getAssertion()) {
+            if (st.getPredicate().equals(HAS_PART)) return st.getObject();
+        }
+        return null;
+    }
+
+    @Test
+    void spaceTokenResolvesFromNavigationContext() throws Exception {
+        withSpaceContext(SPACE_IRI);
+        TemplateContext context = contextWith("~~SPACE~~/r/", SPACE_IRI);
+        assertEquals(SPACE_IRI + "/r/", context.getPrefix(RESOURCE));
+        setText(context, "thing");
+        assertEquals(vf.createIRI(SPACE_IRI + "/r/thing"), partOf(publish(context)));
+    }
+
+    @Test
+    void spaceTokenResolvesToTheSpaceOfAMaintainedResourceContext() throws Exception {
+        String resourceIri = SPACE_IRI + "/collection";
+        withResourceContext(resourceIri, resourceIri, null);
+        TemplateContext context = contextWith("~~SPACE~~/", resourceIri);
+        setText(context, "thing");
+        assertEquals(vf.createIRI(SPACE_IRI + "/thing"), partOf(publish(context)));
+    }
+
+    @Test
+    void namespaceTokenResolvesFromMaintainedResourceContext() throws Exception {
+        String resourceIri = SPACE_IRI + "/collection";
+        withResourceContext(resourceIri, resourceIri, SPACE_IRI + "/ns/");
+        TemplateContext context = contextWith("~~NAMESPACE~~", resourceIri);
+        setText(context, "thing");
+        assertEquals(vf.createIRI(SPACE_IRI + "/ns/thing"), partOf(publish(context)));
+    }
+
+    @Test
+    void namespaceTokenFallsBackToTheResourceIriWhenNoNamespaceIsDeclared() throws Exception {
+        String resourceIri = SPACE_IRI + "/collection";
+        withResourceContext(resourceIri, resourceIri, null);
+        TemplateContext context = contextWith("~~NAMESPACE~~", resourceIri);
+        setText(context, "thing");
+        assertEquals(vf.createIRI(resourceIri + "/thing"), partOf(publish(context)));
+    }
+
+    /**
+     * The headline case: a template that introduces a new resource declares it
+     * nt:LocalResource + nt:IntroducedResource *and* gives it a dynamic prefix. The prefix
+     * must win, otherwise the resource is minted under the nanopublication's own namespace
+     * and the declared namespace is silently dropped.
+     */
+    @Test
+    void dynamicPrefixWinsOverLocalResourceMinting() throws Exception {
+        String resourceIri = SPACE_IRI + "/r/test-ontology";
+        withResourceContext(resourceIri, resourceIri, null);
+        TemplateContext context = contextWith("~~NAMESPACE~~", resourceIri, true);
+        assertEquals(resourceIri + "/", context.getPrefix(RESOURCE));
+        setText(context, "my-class");
+        assertEquals(vf.createIRI(resourceIri + "/my-class"), partOf(publish(context)));
+    }
+
+    @Test
+    void dynamicSpacePrefixWinsOverLocalResourceMinting() throws Exception {
+        withSpaceContext(SPACE_IRI);
+        TemplateContext context = contextWith("~~SPACE~~/r/", SPACE_IRI, true);
+        setText(context, "thing");
+        assertEquals(vf.createIRI(SPACE_IRI + "/r/thing"), partOf(publish(context)));
+    }
+
+    /**
+     * A local resource without a dynamic prefix keeps being minted under the target
+     * namespace, exactly as before.
+     */
+    @Test
+    void localResourceWithoutDynamicPrefixIsStillMintedUnderTheTargetNamespace() throws Exception {
+        TemplateContext context = contextWith("https://example.org/", null, true);
+        setText(context, "thing");
+        Value v = partOf(publish(context));
+        assertNotNull(v);
+        assertTrue(v.stringValue().startsWith(Template.DEFAULT_TARGET_NAMESPACE),
+                "expected minting under the target namespace but got " + v);
+    }
+
+
+    @Test
+    void namespaceTokenIsUnresolvedUnderASpaceContext() throws Exception {
+        withSpaceContext(SPACE_IRI);
+        TemplateContext context = contextWith("~~NAMESPACE~~", SPACE_IRI);
+        assertNull(context.getPrefix(RESOURCE));
+        assertTrue(context.hasUnresolvedPrefix(RESOURCE));
+    }
+
+    @Test
+    void withoutNavigationContextThePickedBaseIsUsed() throws Exception {
+        TemplateContext context = contextWith("~~SPACE~~/r/", null);
+        assertTrue(context.hasUnresolvedPrefix(RESOURCE));
+        pickPrefixBase(context, "~~SPACE~~/r/", "https://w3id.org/space/other");
+        assertEquals("https://w3id.org/space/other/r/", context.getPrefix(RESOURCE));
+        setText(context, "thing");
+        assertEquals(vf.createIRI("https://w3id.org/space/other/r/thing"), partOf(publish(context)));
+    }
+
+    @Test
+    void unresolvedPrefixPublishesNothing() throws Exception {
+        TemplateContext context = contextWith("~~SPACE~~/r/", null);
+        setText(context, "thing");
+        assertNull(partOf(publish(context)), "an unresolved dynamic prefix must not mint an IRI");
+    }
+
+    @Test
+    void aFullUriIsPublishedEvenWithAnUnresolvedPrefix() throws Exception {
+        TemplateContext context = contextWith("~~SPACE~~/r/", null);
+        setText(context, "https://example.org/elsewhere");
+        assertEquals(vf.createIRI("https://example.org/elsewhere"), partOf(publish(context)));
+    }
+
+    @Test
+    void staticPrefixIsUnchanged() throws Exception {
+        TemplateContext context = contextWith("https://example.org/", null);
+        assertEquals("https://example.org/", context.getPrefix(RESOURCE));
+        setText(context, "thing");
+        assertEquals(vf.createIRI("https://example.org/thing"), partOf(publish(context)));
+    }
+
+}