diff --git a/docs/concepts/iri-and-context.md b/docs/concepts/iri-and-context.md
index b0111ac7c..d0d40330f 100644
--- a/docs/concepts/iri-and-context.md
+++ b/docs/concepts/iri-and-context.md
@@ -256,9 +256,13 @@ For programmatic use from Rust, transactions can also set `TxnOpts.strict_compac
 ```
 
 Blank nodes are:
-- Local to a single transaction
-- Cannot be referenced across transactions
-- Useful for temporary or anonymous data
+- Skolemized at insert time into the reserved `_:fdb-...` label space, which
+  queries return as the node's `@id`
+- Addressable afterwards via that stable `_:fdb-...` id in queries and
+  transactions (see
+  [Editing blank-node structures](../transactions/update-where-delete-insert.md#editing-blank-node-structures-stable-_fdb--ids))
+- Client-authored labels (`_:b0`) stay local to a single transaction — reusing
+  the same label later mints a new node
 
 ## Best Practices
 
diff --git a/docs/transactions/insert.md b/docs/transactions/insert.md
index 59d0ccea4..240e7e20f 100644
--- a/docs/transactions/insert.md
+++ b/docs/transactions/insert.md
@@ -280,7 +280,10 @@ Create entities without explicit IRIs:
 }
 ```
 
-Fluree generates a unique IRI for the blank node address.
+Fluree generates a unique IRI for the blank node address, in the reserved
+`_:fdb-...` label space. Queries return that id, and it can be used later to
+address the node directly — see
+[Editing blank-node structures](update-where-delete-insert.md#editing-blank-node-structures-stable-_fdb--ids).
 
 ## Adding to Existing Entities
 
diff --git a/docs/transactions/update-where-delete-insert.md b/docs/transactions/update-where-delete-insert.md
index 75dba38cc..da6a02adf 100644
--- a/docs/transactions/update-where-delete-insert.md
+++ b/docs/transactions/update-where-delete-insert.md
@@ -556,6 +556,65 @@ Calculate new values based on old:
 }
 ```
 
+## Editing Blank-Node Structures (Stable `_:fdb-` Ids)
+
+Fluree skolemizes every blank node at insert time into the reserved
+`_:fdb-...` label space, and queries return those labels as the node's `@id`.
+These ids are **stable**: referencing an `_:fdb-...` id in a later query or
+transaction denotes the existing stored node rather than minting a fresh one
+(the blank-node-syntax equivalent of RDF 1.1 §3.5 skolem IRIs). This makes
+blank-node-rooted structures — OWL restrictions, address objects, RDF lists —
+editable in place, without retracting and re-asserting the whole subtree.
+
+Workflow: query for the node's id, then use it as an ordinary `@id`:
+
+```json
+{
+  "select": "?r",
+  "where": { "@id": "ex:ClassA", "ex:restriction": "?r" }
+}
+```
+
+returns e.g. `"_:fdb-1751612345678901234-0-b0"`, which can then be edited
+directly:
+
+```json
+{
+  "where":  { "@id": "_:fdb-1751612345678901234-0-b0", "owl:someValuesFrom": "?old" },
+  "delete": { "@id": "_:fdb-1751612345678901234-0-b0", "owl:someValuesFrom": "?old" },
+  "insert": { "@id": "_:fdb-1751612345678901234-0-b0", "owl:someValuesFrom": { "@id": "ex:Gadget" } }
+}
+```
+
+The parent's reference to the node is untouched and the node keeps its
+identity across the edit.
+
+The same ids work in SPARQL, in all of SELECT patterns, `DELETE`/`INSERT`
+templates, `DELETE DATA`, `INSERT DATA`, and `DELETE WHERE`:
+
+```sparql
+DELETE { _:fdb-1751612345678901234-0-b0 owl:someValuesFrom ?old }
+INSERT { _:fdb-1751612345678901234-0-b0 owl:someValuesFrom ex:Gadget }
+WHERE  { _:fdb-1751612345678901234-0-b0 owl:someValuesFrom ?old }
+```
+
+Notes:
+
+- Only labels beginning with the reserved `_:fdb-` prefix behave this way.
+  Ordinary client-authored labels (`_:b0`) keep standard RDF semantics: a
+  fresh node per transaction on the write side, and an existential variable
+  in SPARQL WHERE patterns. Clients cannot accidentally collide with the
+  reserved space — transaction skolemization wraps client labels with a
+  transaction id before prefixing `fdb-`.
+- Strictly per spec, SPARQL forbids blank nodes in `DELETE` templates and
+  treats WHERE-pattern labels as variables; accepting `_:fdb-` ids as
+  constants is a deliberate Fluree extension (the same one Virtuoso's
+  `nodeID://` refs and Jena's `<_:label>` syntax provide).
+- Some stable ids minted by bulk import embed `:` characters (e.g.
+  `_:fdb-lubm:main-1-genid10`). These are addressable from JSON-LD, but the
+  SPARQL grammar does not allow `:` inside blank-node labels, so such ids
+  cannot be written in SPARQL syntax.
+
 ## Error Handling
 
 ### No Match
diff --git a/fluree-db-api/src/import.rs b/fluree-db-api/src/import.rs
index 3eadddfc2..b49800118 100644
--- a/fluree-db-api/src/import.rs
+++ b/fluree-db-api/src/import.rs
@@ -4389,8 +4389,9 @@ where
                 let result = if chunk_source.is_trig(i) || chunk_source.is_nquads(i) {
                     // TriG (and N-Quads, converted to TriG) use the dedicated
                     // commit function for named-graph handling. It allocates
-                    // codes in state.ns_registry; sync them to shared_alloc
-                    // afterward for subsequent chunks' spool writes.
+                    // codes through spool_config.ns_alloc (spool prefix
+                    // lookups happen mid-parse); the sync below is a
+                    // belt-and-braces consistency check.
                     let nq_converted;
                     let trig_content: &str = if chunk_source.is_nquads(i) {
                         nq_converted = fluree_db_transact::parse::nquads_to_trig(&content)
diff --git a/fluree-db-api/src/tx.rs b/fluree-db-api/src/tx.rs
index 53db50ff2..0eace5b31 100644
--- a/fluree-db-api/src/tx.rs
+++ b/fluree-db-api/src/tx.rs
@@ -1648,6 +1648,11 @@ fn convert_named_graphs_to_templates(
         match term {
             RawTerm::Iri(iri) => {
                 if let Some(local) = iri.strip_prefix("_:") {
+                    // Stable Fluree blank-node ids address the existing node;
+                    // other labels skolemize fresh at staging.
+                    if let Some(sid) = fluree_db_transact::stable_blank_node_sid_from_label(local) {
+                        return Ok(TemplateTerm::Sid(sid));
+                    }
                     Ok(TemplateTerm::BlankNode(local.to_string()))
                 } else {
                     Ok(TemplateTerm::Sid(ns_registry.sid_for_iri(iri)))
@@ -1670,6 +1675,11 @@ fn convert_named_graphs_to_templates(
         match obj {
             RawObject::Iri(iri) => {
                 if let Some(local) = iri.strip_prefix("_:") {
+                    // Stable Fluree blank-node ids resolve to the stored node
+                    // (see convert_term).
+                    if let Some(sid) = fluree_db_transact::stable_blank_node_sid_from_label(local) {
+                        return Ok((TemplateTerm::Sid(sid), None));
+                    }
                     Ok((TemplateTerm::BlankNode(local.to_string()), None))
                 } else {
                     Ok((TemplateTerm::Sid(ns_registry.sid_for_iri(iri)), None))
@@ -3041,3 +3051,44 @@ impl crate::Fluree {
 fn _ensure_error_used(e: ApiError) -> ApiError {
     e
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use fluree_db_transact::{RawObject, RawTerm, RawTriple};
+
+    /// TriG named-graph blocks (upsert/insert-turtle path): a stable
+    /// `_:fdb-...` id must resolve to the stored node's Sid, while ordinary
+    /// labels stay `TemplateTerm::BlankNode` for fresh skolemization at
+    /// staging.
+    #[test]
+    fn named_graph_stable_blank_node_resolves_to_sid() {
+        let block = NamedGraphBlock {
+            iri: "http://example.org/g1".to_string(),
+            triples: vec![RawTriple {
+                subject: Some(RawTerm::Iri("_:fdb-1234-0-b0".to_string())),
+                predicate: RawTerm::Iri("http://example.org/knows".to_string()),
+                objects: vec![RawObject::Iri("_:other".to_string())],
+            }],
+            prefixes: rustc_hash::FxHashMap::default(),
+        };
+        let mut ns = NamespaceRegistry::new();
+        let (templates, _delta) =
+            convert_named_graphs_to_templates(&[block], &mut ns).expect("convert");
+        assert_eq!(templates.len(), 1);
+
+        let expected = ns.blank_node_sid("1234-0-b0");
+        match &templates[0].subject {
+            TemplateTerm::Sid(sid) => {
+                assert_eq!(sid, &expected, "stable id must address the stored node");
+            }
+            other => panic!("stable id must resolve to a Sid, got {other:?}"),
+        }
+        match &templates[0].object {
+            TemplateTerm::BlankNode(label) => {
+                assert_eq!(label, "other", "ordinary labels keep fresh-mint semantics");
+            }
+            other => panic!("ordinary label must stay BlankNode, got {other:?}"),
+        }
+    }
+}
diff --git a/fluree-db-api/tests/grp_transact.rs b/fluree-db-api/tests/grp_transact.rs
index ba4888e0b..2a451e44a 100644
--- a/fluree-db-api/tests/grp_transact.rs
+++ b/fluree-db-api/tests/grp_transact.rs
@@ -7,6 +7,8 @@ mod it_concurrent_update_reconcile;
 mod it_enforce_unique_upsert_indexed;
 #[path = "it_raw_txn_parallel_upload.rs"]
 mod it_raw_txn_parallel_upload;
+#[path = "it_stable_blank_nodes.rs"]
+mod it_stable_blank_nodes;
 #[path = "it_transact.rs"]
 mod it_transact;
 #[path = "it_transact_conditional.rs"]
diff --git a/fluree-db-api/tests/it_import.rs b/fluree-db-api/tests/it_import.rs
index dee349ea5..5427f5507 100644
--- a/fluree-db-api/tests/it_import.rs
+++ b/fluree-db-api/tests/it_import.rs
@@ -1438,6 +1438,131 @@ ex:alice schema:name "Alice" .
     );
 }
 
+// TriG scopes blank-node labels to the whole document: a label shared between
+// the default graph and a GRAPH block must skolemize to ONE node, and the same
+// label in a different document (file/commit) must stay a DIFFERENT node.
+// Regression: named-graph blanks used to mint from the bare label (`fdb-b0`) —
+// diverging from the default graph within one document AND colliding across
+// every document in the ledger.
+#[tokio::test]
+async fn import_trig_blank_label_document_scoped() {
+    let db_dir = tempfile::tempdir().expect("db tmpdir");
+    let data_dir = tempfile::tempdir().expect("data tmpdir");
+
+    // File 1: `_:shared` referenced from the default graph AND a GRAPH block.
+    let trig1 = r#"@prefix ex: <http://example.org/> .
+@prefix schema: <http://schema.org/> .
+
+ex:alice ex:knows _:shared .
+_:shared schema:name "Document-scoped node" .
+
+GRAPH <http://example.org/graphs/g1> {
+    ex:bob ex:knows _:shared .
+}
+"#;
+    // File 2: the same label in another document's GRAPH block.
+    let trig2 = r"@prefix ex: <http://example.org/> .
+
+GRAPH <http://example.org/graphs/g2> {
+    ex:carol ex:knows _:shared .
+}
+";
+    std::fs::write(data_dir.path().join("a.trig"), trig1).expect("write trig1");
+    std::fs::write(data_dir.path().join("b.trig"), trig2).expect("write trig2");
+
+    let fluree = FlureeBuilder::file(db_dir.path().to_string_lossy().to_string())
+        .build()
+        .expect("build file-backed Fluree");
+
+    fluree
+        .create("test/trig-bnode-scope:main")
+        .import(data_dir.path())
+        .threads(1)
+        .memory_budget_mb(256)
+        .cleanup(false)
+        .execute()
+        .await
+        .expect("trig import should succeed");
+
+    let ledger = fluree
+        .ledger("test/trig-bnode-scope:main")
+        .await
+        .expect("load ledger");
+
+    // Scans with a variable predicate and picks out the blank-node ref, so
+    // the assertions stay focused on node identity rather than predicate
+    // resolution (covered by import_trig_bound_predicate_queryable).
+    let knows_object = |json: &serde_json::Value, subject: &str| -> String {
+        let rows = json.as_array().expect("array result");
+        let refs: Vec<String> = rows
+            .iter()
+            .map(|r| r.as_array().expect("row"))
+            .filter(|r| r[0].as_str() == Some(subject))
+            .filter_map(|r| r[2].as_str())
+            .filter(|o| o.starts_with("_:fdb-"))
+            .map(str::to_string)
+            .collect();
+        assert_eq!(
+            refs.len(),
+            1,
+            "expected one _:fdb- ref for {subject}: {json}"
+        );
+        refs.into_iter().next().unwrap()
+    };
+
+    // Default graph: the node alice knows.
+    let qr = support::query_jsonld(
+        &fluree,
+        &ledger,
+        &json!({
+            "select": ["?s", "?p", "?o"],
+            "where": {"@id": "?s", "?p": "?o"}
+        }),
+    )
+    .await
+    .expect("default-graph query");
+    let default_node = knows_object(
+        &qr.to_jsonld(&ledger.snapshot).expect("jsonld"),
+        "http://example.org/alice",
+    );
+
+    // Named graph g1 (same document): must be the SAME node.
+    let qr = fluree
+        .query_connection(&json!({
+            "from": "test/trig-bnode-scope:main#http://example.org/graphs/g1",
+            "select": ["?s", "?p", "?o"],
+            "where": {"@id": "?s", "?p": "?o"}
+        }))
+        .await
+        .expect("g1 query");
+    let g1_node = knows_object(
+        &qr.to_jsonld(&ledger.snapshot).expect("jsonld"),
+        "http://example.org/bob",
+    );
+    assert_eq!(
+        g1_node, default_node,
+        "TriG label scope spans default graph and GRAPH blocks of one document"
+    );
+
+    // Named graph g2 (different document): must be a DIFFERENT node.
+    let qr = fluree
+        .query_connection(&json!({
+            "from": "test/trig-bnode-scope:main#http://example.org/graphs/g2",
+            "select": ["?s", "?p", "?o"],
+            "where": {"@id": "?s", "?p": "?o"}
+        }))
+        .await
+        .expect("g2 query");
+    let g2_node = knows_object(
+        &qr.to_jsonld(&ledger.snapshot).expect("jsonld"),
+        "http://example.org/carol",
+    );
+    assert_ne!(
+        g2_node, default_node,
+        "the same label in a different document must stay a distinct node"
+    );
+}
+
 // ============================================================================
 // N-Quads (.nq) import
 //
@@ -2082,3 +2207,94 @@ async fn import_directory_splits_large_compressed_file() {
     assert!(objs.contains(&"name-0".to_string()));
     assert!(objs.contains(&"name-39999".to_string()));
 }
+
+// Regression: the serial TriG import path allocated namespace codes only in
+// `state.ns_registry`, invisible to the SpoolContext (which resolves
+// code->prefix via the SHARED allocator at record-push time, mid-parse). Its
+// empty-prefix fallback wrote suffix-only predicate strings ("name" instead
+// of "http://schema.org/name") into the index's predicate dict, so
+// bound-predicate patterns matched nothing and results rendered bare
+// suffixes. The TriG path now allocates through a shared-allocator-backed
+// WorkerCache like the parallel Turtle path.
+#[tokio::test]
+async fn import_trig_bound_predicate_queryable() {
+    let db_dir = tempfile::tempdir().expect("db tmpdir");
+    let data_dir = tempfile::tempdir().expect("data tmpdir");
+    let trig = r#"@prefix ex: <http://example.org/> .
+@prefix schema: <http://schema.org/> .
+
+ex:alice schema:name "Alice" .
+ex:bob schema:name "Bob" .
+
+GRAPH <http://example.org/graphs/g1> {
+    ex:event1 schema:description "login" .
+}
+"#;
+    let path = data_dir.path().join("data.trig");
+    std::fs::write(&path, trig).expect("write trig");
+
+    let fluree = FlureeBuilder::file(db_dir.path().to_string_lossy().to_string())
+        .build()
+        .expect("build");
+    fluree
+        .create("test/bound-pred:main")
+        .import(&path)
+        .threads(1)
+        .memory_budget_mb(256)
+        .cleanup(false)
+        .execute()
+        .await
+        .expect("import");
+    let ledger = fluree.ledger("test/bound-pred:main").await.expect("ledger");
+
+    // Full scan must render complete predicate IRIs (not bare suffixes).
+    let scan = support::query_jsonld(
+        &fluree,
+        &ledger,
+        &json!({"select": ["?s","?p","?o"], "where": {"@id": "?s", "?p": "?o"}}),
+    )
+    .await
+    .expect("scan");
+    let scan_rows = scan.to_jsonld(&ledger.snapshot).expect("jsonld");
+    let preds: Vec<&str> = scan_rows
+        .as_array()
+        .expect("array")
+        .iter()
+        .filter_map(|r| r.as_array().and_then(|row| row[1].as_str()))
+        .collect();
+    assert!(
+        preds.iter().all(|p| *p == "http://schema.org/name"),
+        "predicates must decode to full IRIs; got {scan_rows}"
+    );
+
+    // Bound-predicate pattern must match via the index predicate dict.
+    let bound = support::query_jsonld(
+        &fluree,
+        &ledger,
+        &json!({"select": ["?s","?o"], "where": {"@id": "?s", "http://schema.org/name": "?o"}}),
+    )
+    .await
+    .expect("bound");
+    let bound_rows = bound.to_jsonld(&ledger.snapshot).expect("jsonld");
+    assert_eq!(
+        bound_rows.as_array().map(Vec::len),
+        Some(2),
+        "bound-predicate must match both subjects; got {bound_rows}"
+    );
+
+    // Named graph too: bound predicate against the GRAPH-block data.
+    let named = fluree
+        .query_connection(&json!({
+            "from": "test/bound-pred:main#http://example.org/graphs/g1",
+            "select": ["?s","?o"],
+            "where": {"@id": "?s", "http://schema.org/description": "?o"}
+        }))
+        .await
+        .expect("named bound");
+    let named_rows = named.to_jsonld(&ledger.snapshot).expect("jsonld");
+    assert_eq!(
+        named_rows.as_array().map(Vec::len),
+        Some(1),
+        "named-graph bound-predicate must match; got {named_rows}"
+    );
+}
diff --git a/fluree-db-api/tests/it_stable_blank_nodes.rs b/fluree-db-api/tests/it_stable_blank_nodes.rs
new file mode 100644
index 000000000..bb6224c75
--- /dev/null
+++ b/fluree-db-api/tests/it_stable_blank_nodes.rs
@@ -0,0 +1,417 @@
+//! Stable Fluree blank-node identifier tests.
+//!
+//! Fluree skolemizes every blank node into the reserved `_:fdb-...` label
+//! space at insert time. These ids are returned by queries and — as pinned
+//! here — are *stable*: when a later query or transaction references an
+//! `_:fdb-...` label, it denotes the existing stored node instead of minting
+//! a fresh one (RDF 1.1 §3.5 skolemization, kept in blank-node syntax). This
+//! makes blank-node-rooted structures (e.g. OWL restrictions) editable in
+//! place, without retracting and re-asserting the whole subtree.
+//!
+//! Ordinary client-authored labels (`_:b0`) keep standard semantics: fresh
+//! node per transaction on the write side, existential variable in SPARQL
+//! WHERE patterns.
+
+use crate::support;
+use fluree_db_api::{FlureeBuilder, LedgerState, Novelty};
+use fluree_db_core::LedgerSnapshot;
+use serde_json::{json, Value as JsonValue};
+
+fn ctx() -> JsonValue {
+    json!({
+        "ex": "http://example.org/",
+        "owl": "http://www.w3.org/2002/07/owl#"
+    })
+}
+
+/// Seed a class with a single OWL-restriction-like structure rooted at an
+/// anonymous blank node and return the fluree handle + ledger.
+async fn seed_restriction(ledger_id: &str) -> (fluree_db_api::Fluree, LedgerState) {
+    let fluree = FlureeBuilder::memory().build_memory();
+    let db0 = LedgerSnapshot::genesis(ledger_id);
+    let ledger0 = LedgerState::new(db0, Novelty::new(0));
+
+    let seeded = fluree
+        .update(
+            ledger0,
+            &json!({
+                "@context": ctx(),
+                "insert": {
+                    "@id": "ex:ClassA",
+                    "ex:restriction": {
+                        "owl:onProperty": {"@id": "ex:hasPart"},
+                        "owl:someValuesFrom": {"@id": "ex:Widget"}
+                    }
+                }
+            }),
+        )
+        .await
+        .expect("seed insert");
+    (fluree, seeded.ledger)
+}
+
+async fn select_strings(
+    fluree: &fluree_db_api::Fluree,
+    ledger: &LedgerState,
+    query: &JsonValue,
+) -> Vec<String> {
+    let result = support::query_jsonld(fluree, ledger, query)
+        .await
+        .expect("query");
+    let v = result.to_jsonld(&ledger.snapshot).expect("to_jsonld");
+    let mut out: Vec<String> = v
+        .as_array()
+        .expect("array result")
+        .iter()
+        .map(|x| x.as_str().expect("string binding").to_string())
+        .collect();
+    out.sort();
+    out
+}
+
+/// The `_:fdb-...` id of ex:ClassA's restriction node.
+async fn restriction_id(fluree: &fluree_db_api::Fluree, ledger: &LedgerState) -> String {
+    let ids = select_strings(
+        fluree,
+        ledger,
+        &json!({
+            "@context": ctx(),
+            "select": "?r",
+            "where": {"@id": "ex:ClassA", "ex:restriction": "?r"}
+        }),
+    )
+    .await;
+    assert_eq!(ids.len(), 1, "exactly one restriction node: {ids:?}");
+    let id = ids.into_iter().next().unwrap();
+    assert!(
+        id.starts_with("_:fdb-"),
+        "restriction id should be a stable Fluree blank-node id, got {id}"
+    );
+    id
+}
+
+async fn run_sparql_update(
+    fluree: &fluree_db_api::Fluree,
+    ledger: LedgerState,
+    sparql: &str,
+) -> fluree_db_api::TransactResult {
+    let parsed = fluree_db_sparql::parse_sparql(sparql);
+    assert!(
+        !parsed.has_errors(),
+        "SPARQL parse errors: {:?}",
+        parsed.diagnostics
+    );
+    let ast = parsed.ast.expect("SPARQL AST");
+    let mut ns = fluree_db_transact::NamespaceRegistry::from_db(&ledger.snapshot);
+    let txn = fluree_db_transact::lower_sparql_update_ast(
+        &ast,
+        &mut ns,
+        fluree_db_transact::TxnOpts::default(),
+    )
+    .expect("lower SPARQL UPDATE");
+    fluree
+        .stage_owned(ledger)
+        .txn(txn)
+        .execute()
+        .await
+        .expect("stage SPARQL UPDATE")
+}
+
+// ============================================================================
+// JSON-LD transactions
+// ============================================================================
+
+/// Inserting with a stable id must extend the existing node, not mint a new
+/// one.
+#[tokio::test]
+async fn jsonld_insert_extends_existing_blank_node() {
+    let (fluree, ledger) = seed_restriction("it/stable-bnode:jsonld-insert").await;
+    let bnode = restriction_id(&fluree, &ledger).await;
+
+    let ledger = fluree
+        .update(
+            ledger,
+            &json!({
+                "@context": ctx(),
+                "insert": {"@id": bnode, "ex:note": "edited"}
+            }),
+        )
+        .await
+        .expect("insert on stable id")
+        .ledger;
+
+    // The note is reachable through the parent's ref — proof the triple
+    // landed on the same node.
+    let notes = select_strings(
+        &fluree,
+        &ledger,
+        &json!({
+            "@context": ctx(),
+            "select": "?note",
+            "where": {"@id": "ex:ClassA", "ex:restriction": {"ex:note": "?note"}}
+        }),
+    )
+    .await;
+    assert_eq!(notes, vec!["edited"]);
+
+    // Still exactly one restriction-shaped node in the ledger.
+    let restrictions = select_strings(
+        &fluree,
+        &ledger,
+        &json!({
+            "@context": ctx(),
+            "select": "?r",
+            "where": {"@id": "?r", "owl:onProperty": {"@id": "ex:hasPart"}}
+        }),
+    )
+    .await;
+    assert_eq!(restrictions.len(), 1);
+}
+
+/// where/delete/insert against a stable id edits the node in place: the
+/// parent's reference is untouched and the node id survives the edit.
+#[tokio::test]
+async fn jsonld_delete_insert_edits_blank_node_in_place() {
+    let (fluree, ledger) = seed_restriction("it/stable-bnode:jsonld-edit").await;
+    let bnode = restriction_id(&fluree, &ledger).await;
+
+    let ledger = fluree
+        .update(
+            ledger,
+            &json!({
+                "@context": ctx(),
+                "where":  {"@id": bnode, "owl:someValuesFrom": "?old"},
+                "delete": {"@id": bnode, "owl:someValuesFrom": "?old"},
+                "insert": {"@id": bnode, "owl:someValuesFrom": {"@id": "ex:Gadget"}}
+            }),
+        )
+        .await
+        .expect("edit restriction in place")
+        .ledger;
+
+    let values = select_strings(
+        &fluree,
+        &ledger,
+        &json!({
+            "@context": ctx(),
+            "select": "?v",
+            "where": {"@id": "ex:ClassA", "ex:restriction": {"owl:someValuesFrom": "?v"}}
+        }),
+    )
+    .await;
+    assert_eq!(values, vec!["ex:Gadget"]);
+
+    // Node identity is stable across the edit.
+    assert_eq!(restriction_id(&fluree, &ledger).await, bnode);
+}
+
+/// Ordinary blank-node labels keep fresh-mint semantics: the same label in
+/// two transactions produces two distinct nodes.
+#[tokio::test]
+async fn jsonld_plain_blank_label_still_mints_fresh() {
+    let fluree = FlureeBuilder::memory().build_memory();
+    let db0 = LedgerSnapshot::genesis("it/stable-bnode:fresh-mint");
+    let mut ledger = LedgerState::new(db0, Novelty::new(0));
+
+    for tag in ["one", "two"] {
+        ledger = fluree
+            .update(
+                ledger,
+                &json!({
+                    "@context": ctx(),
+                    "insert": {"@id": "_:b0", "ex:tag": tag}
+                }),
+            )
+            .await
+            .expect("insert")
+            .ledger;
+    }
+
+    let subjects = select_strings(
+        &fluree,
+        &ledger,
+        &json!({
+            "@context": ctx(),
+            "select": "?s",
+            "where": {"@id": "?s", "ex:tag": "?t"}
+        }),
+    )
+    .await;
+    assert_eq!(
+        subjects.len(),
+        2,
+        "same client label across transactions must mint distinct nodes: {subjects:?}"
+    );
+}
+
+// ============================================================================
+// SPARQL
+// ============================================================================
+
+/// A stable id in a SPARQL WHERE pattern is a constant pinned to the stored
+/// node, while an ordinary label stays an existential variable.
+#[tokio::test]
+async fn sparql_select_stable_blank_node_is_constant() {
+    let (fluree, ledger) = seed_restriction("it/stable-bnode:sparql-select").await;
+
+    // Add a second restriction so a wildcard match would return two rows.
+    let ledger = fluree
+        .update(
+            ledger,
+            &json!({
+                "@context": ctx(),
+                "insert": {
+                    "@id": "ex:ClassB",
+                    "ex:restriction": {
+                        "owl:onProperty": {"@id": "ex:hasPart"},
+                        "owl:someValuesFrom": {"@id": "ex:Sprocket"}
+                    }
+                }
+            }),
+        )
+        .await
+        .expect("insert ClassB")
+        .ledger;
+    let bnode = restriction_id(&fluree, &ledger).await;
+
+    // Constant: only the addressed node's value comes back.
+    let sparql = format!(
+        "PREFIX owl: <http://www.w3.org/2002/07/owl#>\n\
+         SELECT ?v WHERE {{ {bnode} owl:someValuesFrom ?v }}"
+    );
+    let result = support::query_sparql(&fluree, &ledger, &sparql)
+        .await
+        .expect("sparql select");
+    let v = result.to_jsonld(&ledger.snapshot).expect("to_jsonld");
+    let rows = v.as_array().expect("array");
+    assert_eq!(rows.len(), 1, "stable id must pin one node: {rows:?}");
+
+    // Ordinary label: existential variable, matches both restrictions.
+    let sparql = "PREFIX owl: <http://www.w3.org/2002/07/owl#>\n\
+                  SELECT ?v WHERE { _:b0 owl:someValuesFrom ?v }";
+    let result = support::query_sparql(&fluree, &ledger, sparql)
+        .await
+        .expect("sparql select wildcard");
+    let v = result.to_jsonld(&ledger.snapshot).expect("to_jsonld");
+    assert_eq!(
+        v.as_array().expect("array").len(),
+        2,
+        "plain blank label must stay a variable"
+    );
+}
+
+/// SPARQL DELETE/INSERT WHERE addressing a stable id edits the node in place.
+#[tokio::test]
+async fn sparql_delete_insert_edits_blank_node() {
+    let (fluree, ledger) = seed_restriction("it/stable-bnode:sparql-edit").await;
+    let bnode = restriction_id(&fluree, &ledger).await;
+
+    let sparql = format!(
+        "PREFIX ex: <http://example.org/>\n\
+         PREFIX owl: <http://www.w3.org/2002/07/owl#>\n\
+         DELETE {{ {bnode} owl:someValuesFrom ?old }}\n\
+         INSERT {{ {bnode} owl:someValuesFrom ex:Gadget }}\n\
+         WHERE  {{ {bnode} owl:someValuesFrom ?old }}"
+    );
+    let ledger = run_sparql_update(&fluree, ledger, &sparql).await.ledger;
+
+    let values = select_strings(
+        &fluree,
+        &ledger,
+        &json!({
+            "@context": ctx(),
+            "select": "?v",
+            "where": {"@id": "ex:ClassA", "ex:restriction": {"owl:someValuesFrom": "?v"}}
+        }),
+    )
+    .await;
+    assert_eq!(values, vec!["ex:Gadget"]);
+    assert_eq!(restriction_id(&fluree, &ledger).await, bnode);
+}
+
+/// SPARQL DELETE DATA / INSERT DATA with a stable id retract and assert
+/// exact triples on the stored node.
+#[tokio::test]
+async fn sparql_delete_data_and_insert_data_stable_blank_node() {
+    let (fluree, ledger) = seed_restriction("it/stable-bnode:sparql-data").await;
+    let bnode = restriction_id(&fluree, &ledger).await;
+
+    let sparql = format!(
+        "PREFIX ex: <http://example.org/>\n\
+         PREFIX owl: <http://www.w3.org/2002/07/owl#>\n\
+         DELETE DATA {{ {bnode} owl:someValuesFrom ex:Widget }}"
+    );
+    let ledger = run_sparql_update(&fluree, ledger, &sparql).await.ledger;
+
+    let values = select_strings(
+        &fluree,
+        &ledger,
+        &json!({
+            "@context": ctx(),
+            "select": "?v",
+            "where": {"@id": "ex:ClassA", "ex:restriction": {"owl:someValuesFrom": "?v"}}
+        }),
+    )
+    .await;
+    assert!(values.is_empty(), "DELETE DATA must retract: {values:?}");
+
+    let sparql = format!(
+        "PREFIX ex: <http://example.org/>\n\
+         PREFIX owl: <http://www.w3.org/2002/07/owl#>\n\
+         INSERT DATA {{ {bnode} owl:someValuesFrom ex:Gadget }}"
+    );
+    let ledger = run_sparql_update(&fluree, ledger, &sparql).await.ledger;
+
+    let values = select_strings(
+        &fluree,
+        &ledger,
+        &json!({
+            "@context": ctx(),
+            "select": "?v",
+            "where": {"@id": "ex:ClassA", "ex:restriction": {"owl:someValuesFrom": "?v"}}
+        }),
+    )
+    .await;
+    assert_eq!(
+        values,
+        vec!["ex:Gadget"],
+        "INSERT DATA must extend the existing node"
+    );
+}
+
+/// DELETE WHERE with a stable-id subject retracts that node's matching
+/// triples only.
+#[tokio::test]
+async fn sparql_delete_where_stable_blank_node() {
+    let (fluree, ledger) = seed_restriction("it/stable-bnode:sparql-delete-where").await;
+    let bnode = restriction_id(&fluree, &ledger).await;
+
+    let sparql = format!("DELETE WHERE {{ {bnode} ?p ?o }}");
+    let ledger = run_sparql_update(&fluree, ledger, &sparql).await.ledger;
+
+    let props = select_strings(
+        &fluree,
+        &ledger,
+        &json!({
+            "@context": ctx(),
+            "select": "?p",
+            "where": {"@id": bnode, "?p": "?o"}
+        }),
+    )
+    .await;
+    assert!(props.is_empty(), "node must be emptied: {props:?}");
+
+    // The parent's ref to the (now-empty) node is a separate triple and
+    // survives — retract it explicitly if the whole subtree should go.
+    let refs = select_strings(
+        &fluree,
+        &ledger,
+        &json!({
+            "@context": ctx(),
+            "select": "?r",
+            "where": {"@id": "ex:ClassA", "ex:restriction": "?r"}
+        }),
+    )
+    .await;
+    assert_eq!(refs, vec![bnode]);
+}
diff --git a/fluree-db-core/src/ns_encoding.rs b/fluree-db-core/src/ns_encoding.rs
index 618d9c840..eb39722ff 100644
--- a/fluree-db-core/src/ns_encoding.rs
+++ b/fluree-db-core/src/ns_encoding.rs
@@ -121,6 +121,27 @@ pub fn builtin_prefix_trie() -> &'static PrefixTrie {
 /// split at this boundary unconditionally, before any other splitting logic.
 pub const BLANK_NODE_PREFIX: &str = "_:";
 
+/// Label prefix reserved for Fluree-minted stable blank-node identifiers.
+///
+/// Every skolemized blank node the system mints has a local name beginning
+/// with `fdb-` (e.g. `fdb-<ulid>`, `fdb-<txn>-<label>`), rendered as
+/// `_:fdb-...` in query results. Labels with this prefix are reserved: when
+/// they appear in incoming queries or transactions they denote the *existing*
+/// stored node rather than minting a fresh one (RDF 1.1 §3.5 skolemization,
+/// kept in blank-node syntax). Client-chosen labels never collide because
+/// transaction skolemization wraps them with a txn id before adding `fdb-`.
+pub const STABLE_BLANK_NODE_LABEL_PREFIX: &str = "fdb-";
+
+/// If `iri` is a Fluree stable blank-node identifier (`_:fdb-...`), return
+/// its local name (the part after `_:`, keeping the `fdb-` prefix) so it can
+/// be resolved directly to the stored blank-node Sid. Returns `None` for
+/// ordinary blank-node labels, which keep fresh-mint semantics.
+#[inline]
+pub fn stable_blank_node_local(iri: &str) -> Option<&str> {
+    iri.strip_prefix(BLANK_NODE_PREFIX)
+        .filter(|local| local.starts_with(STABLE_BLANK_NODE_LABEL_PREFIX))
+}
+
 /// Deterministically split an IRI into `(prefix, suffix)` based on the
 /// ledger's split mode.
 ///
@@ -971,6 +992,21 @@ mod tests {
         assert_eq!(s, "fdb-abc123");
     }
 
+    #[test]
+    fn stable_blank_node_local_reserved_form_only() {
+        assert_eq!(stable_blank_node_local("_:fdb-abc123"), Some("fdb-abc123"));
+        assert_eq!(
+            stable_blank_node_local("_:fdb-lubm:main-1-genid10"),
+            Some("fdb-lubm:main-1-genid10")
+        );
+        // Ordinary labels, near-misses, and non-blank strings are not stable ids.
+        assert_eq!(stable_blank_node_local("_:b0"), None);
+        assert_eq!(stable_blank_node_local("_:fdb"), None);
+        assert_eq!(stable_blank_node_local("_:fdbx-1"), None);
+        assert_eq!(stable_blank_node_local("fdb-abc123"), None);
+        assert_eq!(stable_blank_node_local("http://example.org/x"), None);
+    }
+
     #[test]
     fn blank_node_with_embedded_colons() {
         // Skolemized blank node locals embed `<ledger>:<branch>` (colons). The
diff --git a/fluree-db-sparql/src/lower/term.rs b/fluree-db-sparql/src/lower/term.rs
index 08f088626..76d587be6 100644
--- a/fluree-db-sparql/src/lower/term.rs
+++ b/fluree-db-sparql/src/lower/term.rs
@@ -10,6 +10,7 @@ use crate::ast::term::{
 };
 use crate::ast::TriplePattern as SparqlTriplePattern;
 
+use fluree_db_core::ns_encoding::STABLE_BLANK_NODE_LABEL_PREFIX;
 use fluree_db_core::temporal::{
     DayTimeDuration, Duration, GDay, GMonth, GMonthDay, GYear, GYearMonth, YearMonthDuration,
 };
@@ -73,6 +74,16 @@ impl<E: IriEncoder> LoweringContext<'_, E> {
             SubjectTerm::Iri(iri) => self.lower_iri_ref(iri),
             SubjectTerm::BlankNode(bn) => match &bn.value {
                 BlankNodeValue::Labeled(label) => {
+                    // Stable Fluree blank-node ids (`_:fdb-...`) denote the
+                    // stored node, so they lower to a constant like an IRI;
+                    // other labels are non-distinguished variables per spec.
+                    if label.starts_with(STABLE_BLANK_NODE_LABEL_PREFIX) {
+                        let full_iri = format!("_:{label}");
+                        return Ok(match self.encoder.encode_iri_strict(&full_iri) {
+                            Some(sid) => Ref::Sid(sid),
+                            None => Ref::Iri(Arc::from(full_iri)),
+                        });
+                    }
                     let var_id = self.vars.get_or_insert(&format!("_:{label}"));
                     Ok(Ref::Var(var_id))
                 }
@@ -116,6 +127,15 @@ impl<E: IriEncoder> LoweringContext<'_, E> {
             SparqlTerm::Literal(lit) => self.lower_literal(lit),
             SparqlTerm::BlankNode(bn) => match &bn.value {
                 BlankNodeValue::Labeled(label) => {
+                    // Stable Fluree blank-node ids lower to a constant
+                    // (see lower_subject).
+                    if label.starts_with(STABLE_BLANK_NODE_LABEL_PREFIX) {
+                        let full_iri = format!("_:{label}");
+                        return Ok(match self.encoder.encode_iri_strict(&full_iri) {
+                            Some(sid) => Term::Sid(sid),
+                            None => Term::Iri(Arc::from(full_iri)),
+                        });
+                    }
                     let var_id = self.vars.get_or_insert(&format!("_:{label}"));
                     Ok(Term::Var(var_id))
                 }
diff --git a/fluree-db-transact/src/flake_sink.rs b/fluree-db-transact/src/flake_sink.rs
index aeebedf7c..4d2749ab2 100644
--- a/fluree-db-transact/src/flake_sink.rs
+++ b/fluree-db-transact/src/flake_sink.rs
@@ -202,7 +202,10 @@ impl GraphSink for FlakeSink<'_> {
                 if let Some(&id) = self.blank_labels.get(l) {
                     return id;
                 }
-                let sid = self.skolemize(l);
+                // Stable Fluree blank-node ids (`fdb-...`) address the
+                // existing stored node; other labels skolemize fresh.
+                let sid = crate::namespace::stable_blank_node_sid_from_label(l)
+                    .unwrap_or_else(|| self.skolemize(l));
                 let id = self.add_term(ResolvedTerm::Sid(sid));
                 self.blank_labels.insert(l.to_string(), id);
                 id
diff --git a/fluree-db-transact/src/import.rs b/fluree-db-transact/src/import.rs
index a4e0810aa..06d2bccfd 100644
--- a/fluree-db-transact/src/import.rs
+++ b/fluree-db-transact/src/import.rs
@@ -151,7 +151,17 @@ mod inner {
             ns_codes = ns_codes_before,
         )
         .entered();
-        let mut sink = ImportSink::new(&mut state.ns_registry, new_t, txn_id, compress)
+        // Allocate namespace codes through the spool's shared allocator when
+        // spooling — SpoolContext resolves code→prefix at record-push time
+        // (mid-parse), so registry-only codes would fall back to an empty
+        // prefix and write suffix-only strings into the index dicts. See the
+        // matching comment in `import_trig_commit`.
+        let shared_ns: Arc<SharedNamespaceAllocator> = match spool_config {
+            Some(cfg) => Arc::clone(&cfg.ns_alloc),
+            None => Arc::new(SharedNamespaceAllocator::from_registry(&state.ns_registry)),
+        };
+        let mut worker_cache = WorkerCache::new(Arc::clone(&shared_ns));
+        let mut sink = ImportSink::new_cached(&mut worker_cache, new_t, txn_id, compress)
             .map_err(|e| TransactError::Parse(format!("failed to create import sink: {e}")))?;
 
         if let Some((dir, config)) = spool_dir.zip(spool_config) {
@@ -175,6 +185,17 @@ mod inner {
 
             let spool_result = spool_ctx.map(crate::import_sink::SpoolContext::finish_buffered);
             let op_count = writer.op_count();
+
+            // Adopt this commit's shared-allocator codes into the registry so
+            // take_delta() includes them in the commit's namespace_delta.
+            let new_codes = worker_cache.into_new_codes();
+            if !new_codes.is_empty() {
+                let adopted = shared_ns.lookup_codes(&new_codes);
+                state
+                    .ns_registry
+                    .adopt_delta_for_persistence(&adopted)
+                    .map_err(|e| TransactError::Parse(format!("namespace adopt conflict: {e}")))?;
+            }
             let ns_delta = state.ns_registry.take_delta();
             let ns_codes_after = state.ns_registry.code_count();
 
@@ -285,7 +306,14 @@ mod inner {
             ns_codes = ns_codes_before,
         )
         .entered();
-        let mut sink = ImportSink::new(&mut state.ns_registry, new_t, txn_id, compress)
+        // Shared-allocator-backed allocation for spool prefix visibility;
+        // see the comment in `import_commit`.
+        let shared_ns: Arc<SharedNamespaceAllocator> = match spool_config {
+            Some(cfg) => Arc::clone(&cfg.ns_alloc),
+            None => Arc::new(SharedNamespaceAllocator::from_registry(&state.ns_registry)),
+        };
+        let mut worker_cache = WorkerCache::new(Arc::clone(&shared_ns));
+        let mut sink = ImportSink::new_cached(&mut worker_cache, new_t, txn_id, compress)
             .map_err(|e| TransactError::Parse(format!("failed to create import sink: {e}")))?;
 
         if let Some((dir, config)) = spool_dir.zip(spool_config) {
@@ -312,6 +340,15 @@ mod inner {
 
             let spool_result = spool_ctx.map(crate::import_sink::SpoolContext::finish_buffered);
             let op_count = writer.op_count();
+
+            let new_codes = worker_cache.into_new_codes();
+            if !new_codes.is_empty() {
+                let adopted = shared_ns.lookup_codes(&new_codes);
+                state
+                    .ns_registry
+                    .adopt_delta_for_persistence(&adopted)
+                    .map_err(|e| TransactError::Parse(format!("namespace adopt conflict: {e}")))?;
+            }
             let ns_delta = state.ns_registry.take_delta();
             let ns_codes_after = state.ns_registry.code_count();
 
@@ -439,9 +476,25 @@ mod inner {
         )
         .entered();
 
-        // 2. Create ImportSink and parse default graph Turtle
-        let mut sink = ImportSink::new(&mut state.ns_registry, new_t, txn_id.clone(), compress)
-            .map_err(|e| TransactError::Parse(format!("failed to create import sink: {e}")))?;
+        // 2. Create ImportSink and parse default graph Turtle.
+        //
+        // Namespace codes MUST be allocated through the spool's shared
+        // allocator (not `state.ns_registry` directly): SpoolContext resolves
+        // code→prefix via `ns_alloc` at record-push time — i.e. DURING the
+        // parse, right after an `@prefix` directive allocates the code. Codes
+        // that only live in the registry are invisible to it, and its
+        // empty-prefix fallback would permanently write suffix-only predicate
+        // strings into the index's predicate dict (breaking bound-predicate
+        // lookups after import). Without spooling, a throwaway allocator
+        // seeded from the registry preserves exact code assignment.
+        let shared_ns: Arc<SharedNamespaceAllocator> = match spool_config {
+            Some(cfg) => Arc::clone(&cfg.ns_alloc),
+            None => Arc::new(SharedNamespaceAllocator::from_registry(&state.ns_registry)),
+        };
+        let mut worker_cache = WorkerCache::new(Arc::clone(&shared_ns));
+        let mut sink =
+            ImportSink::new_cached(&mut worker_cache, new_t, txn_id.clone(), compress)
+                .map_err(|e| TransactError::Parse(format!("failed to create import sink: {e}")))?;
 
         if let Some((dir, config)) = spool_dir.zip(spool_config) {
             let spool_path = dir.join(format!("chunk_{chunk_idx}.spool"));
@@ -497,7 +550,7 @@ mod inner {
             };
 
             // Create a graph Sid (using the graph IRI's namespace + local name)
-            let graph_sid = state.ns_registry.sid_for_iri(&block.iri);
+            let graph_sid = worker_cache.sid_for_iri(&block.iri);
 
             // Process each triple in this named graph
             for triple in &block.triples {
@@ -505,12 +558,17 @@ mod inner {
                     TransactError::Parse("named graph triple missing subject".to_string())
                 })?;
 
-                let s = expand_term(subject, &block.prefixes, &mut state.ns_registry)?;
-                let p = expand_term(&triple.predicate, &block.prefixes, &mut state.ns_registry)?;
+                let s = expand_term(subject, &block.prefixes, &mut worker_cache, &txn_id)?;
+                let p = expand_term(
+                    &triple.predicate,
+                    &block.prefixes,
+                    &mut worker_cache,
+                    &txn_id,
+                )?;
 
                 for obj in &triple.objects {
                     let (o, dt, lang) =
-                        expand_object(obj, &block.prefixes, &mut state.ns_registry)?;
+                        expand_object(obj, &block.prefixes, &mut worker_cache, &txn_id)?;
 
                     // Spool the named-graph flake under its g_id (so it enters
                     // the index), then encode it into the commit blob.
@@ -553,6 +611,18 @@ mod inner {
         let spool_result = spool_ctx.map(crate::import_sink::SpoolContext::finish_buffered);
         drop(_parse_span);
 
+        // Adopt codes this commit allocated in the shared allocator into the
+        // registry, recording them for persistence so take_delta() below
+        // includes them in this commit's namespace_delta.
+        let new_codes = worker_cache.into_new_codes();
+        if !new_codes.is_empty() {
+            let adopted = shared_ns.lookup_codes(&new_codes);
+            state
+                .ns_registry
+                .adopt_delta_for_persistence(&adopted)
+                .map_err(|e| TransactError::Parse(format!("namespace adopt conflict: {e}")))?;
+        }
+
         // 5. Resolve txn-meta if present
         let txn_meta = if let Some(ref raw_meta) = phase1.raw_meta {
             resolve_trig_meta(raw_meta, &mut state.ns_registry)?
@@ -630,27 +700,37 @@ mod inner {
         })
     }
 
-    /// Expand a RawTerm to a Sid using the prefix map and namespace registry.
+    /// Expand a RawTerm to a Sid using the prefix map and worker cache.
+    ///
+    /// Allocation goes through the shared-allocator-backed [`WorkerCache`] so
+    /// the spool's prefix lookups see codes the moment they're allocated (see
+    /// the comment in `import_trig_commit`).
+    ///
+    /// Blank-node labels are skolemized with the same `{txn_id}-{label}` key
+    /// as `ImportSink::skolemize`, so a label shared between the default graph
+    /// and a named-graph block of one TriG document resolves to one node
+    /// (TriG scopes labels to the whole document), while the same label in a
+    /// different document/commit stays distinct.
     fn expand_term(
         term: &RawTerm,
         prefixes: &rustc_hash::FxHashMap<String, String>,
-        ns_registry: &mut NamespaceRegistry,
+        ns: &mut WorkerCache,
+        txn_id: &str,
     ) -> Result<Sid> {
         match term {
             RawTerm::Iri(iri) => {
                 if let Some(local) = iri.strip_prefix("_:") {
-                    // Blank node - skolemize
-                    Ok(ns_registry.blank_node_sid(local))
+                    Ok(ns.blank_node_sid(&format!("{txn_id}-{local}")))
                 } else {
-                    Ok(ns_registry.sid_for_iri(iri))
+                    Ok(ns.sid_for_iri(iri))
                 }
             }
             RawTerm::PrefixedName { prefix, local } => {
-                let ns = prefixes
+                let namespace = prefixes
                     .get(prefix.as_str())
                     .ok_or_else(|| TransactError::Parse(format!("undefined prefix: {prefix}")))?;
-                let iri = format!("{ns}{local}");
-                Ok(ns_registry.sid_for_iri(&iri))
+                let iri = format!("{namespace}{local}");
+                Ok(ns.sid_for_iri(&iri))
             }
         }
     }
@@ -659,23 +739,25 @@ mod inner {
     fn expand_object(
         obj: &RawObject,
         prefixes: &rustc_hash::FxHashMap<String, String>,
-        ns_registry: &mut NamespaceRegistry,
+        ns: &mut WorkerCache,
+        txn_id: &str,
     ) -> Result<(FlakeValue, Sid, Option<String>)> {
         match obj {
             RawObject::Iri(iri) => {
+                // Blank labels use the ImportSink skolem key; see expand_term.
                 let sid = if let Some(local) = iri.strip_prefix("_:") {
-                    ns_registry.blank_node_sid(local)
+                    ns.blank_node_sid(&format!("{txn_id}-{local}"))
                 } else {
-                    ns_registry.sid_for_iri(iri)
+                    ns.sid_for_iri(iri)
                 };
                 Ok((FlakeValue::Ref(sid), DT_ID.clone(), None))
             }
             RawObject::PrefixedName { prefix, local } => {
-                let ns = prefixes
+                let namespace = prefixes
                     .get(prefix.as_str())
                     .ok_or_else(|| TransactError::Parse(format!("undefined prefix: {prefix}")))?;
-                let iri = format!("{ns}{local}");
-                let sid = ns_registry.sid_for_iri(&iri);
+                let iri = format!("{namespace}{local}");
+                let sid = ns.sid_for_iri(&iri);
                 Ok((FlakeValue::Ref(sid), DT_ID.clone(), None))
             }
             RawObject::String(s) => Ok((
@@ -704,11 +786,8 @@ mod inner {
                 Some(lang.clone()),
             )),
             RawObject::TypedLiteral { value, datatype } => {
-                let (fv, dt) = convert_string_literal(
-                    value,
-                    datatype,
-                    &mut NsAllocator::Exclusive(ns_registry),
-                );
+                let (fv, dt) =
+                    convert_string_literal(value, datatype, &mut NsAllocator::Cached(ns));
                 Ok((fv, dt, None))
             }
         }
diff --git a/fluree-db-transact/src/import_sink.rs b/fluree-db-transact/src/import_sink.rs
index 96c216051..c86092038 100644
--- a/fluree-db-transact/src/import_sink.rs
+++ b/fluree-db-transact/src/import_sink.rs
@@ -236,6 +236,43 @@ mod inner {
                 .get_or_insert(sid.namespace_code, sid.name.as_bytes())
         }
 
+        /// Resolve a namespace code to its prefix via the shared allocator,
+        /// caching the result.
+        ///
+        /// A miss for a real (non-OVERFLOW) code means an importer allocated
+        /// the code outside the shared allocator — the dict entry would then
+        /// permanently store a suffix-only string ("name" instead of
+        /// "http://schema.org/name"), silently breaking bound-predicate
+        /// lookups on the imported ledger. Panic in debug so tests catch it;
+        /// warn in release. (OVERFLOW Sids legitimately carry the full IRI in
+        /// `name`, so an empty prefix is correct for them.)
+        fn cache_prefix(&mut self, code: u16) {
+            if self.ns_prefix_cache.contains_key(&code) {
+                return;
+            }
+            let prefix = match self.ns_alloc.get_prefix(code) {
+                Some(p) => p,
+                None => {
+                    debug_assert!(
+                        code >= fluree_vocab::namespaces::OVERFLOW,
+                        "namespace code {code} not registered in the shared allocator — \
+                         the spool dict would store a suffix-only string; allocate import \
+                         codes through the SpoolConfig's ns_alloc (see import_commit)"
+                    );
+                    #[cfg(not(debug_assertions))]
+                    if code < fluree_vocab::namespaces::OVERFLOW {
+                        tracing::warn!(
+                            code,
+                            "namespace code missing from shared allocator; spool dict entry \
+                             will store a bare suffix and bound lookups on it will miss"
+                        );
+                    }
+                    String::new()
+                }
+            };
+            self.ns_prefix_cache.insert(code, prefix);
+        }
+
         /// Assign a global predicate ID via `DictWorkerCache`.
         fn assign_predicate_id(&mut self, sid: &Sid) -> u32 {
             // Look up the namespace prefix, then use parts-based insertion
@@ -245,10 +282,7 @@ mod inner {
             // because that would borrow the whole `SpoolContext` mutably and
             // prevent a simultaneous mutable borrow of `self.predicates`.
             let code = sid.namespace_code;
-            if !self.ns_prefix_cache.contains_key(&code) {
-                let prefix = self.ns_alloc.get_prefix(code).unwrap_or_default();
-                self.ns_prefix_cache.insert(code, prefix);
-            }
+            self.cache_prefix(code);
             let prefix = self
                 .ns_prefix_cache
                 .get(&code)
@@ -260,10 +294,7 @@ mod inner {
         /// Assign a global datatype ID via `DictWorkerCache`.
         fn assign_datatype_id(&mut self, sid: &Sid) -> u16 {
             let code = sid.namespace_code;
-            if !self.ns_prefix_cache.contains_key(&code) {
-                let prefix = self.ns_alloc.get_prefix(code).unwrap_or_default();
-                self.ns_prefix_cache.insert(code, prefix);
-            }
+            self.cache_prefix(code);
             let prefix = self
                 .ns_prefix_cache
                 .get(&code)
@@ -826,6 +857,27 @@ mod inner {
             }
         }
 
+        /// A namespace code the shared allocator has never seen must fail
+        /// loudly (debug builds) instead of silently writing a suffix-only
+        /// string into the spool's predicate dict. Regression pin for the
+        /// serial-TriG-import bug where codes were allocated only in
+        /// `state.ns_registry` and bound-predicate lookups matched nothing.
+        #[test]
+        #[cfg(debug_assertions)]
+        #[should_panic(expected = "not registered in the shared allocator")]
+        fn spool_prefix_miss_panics_in_debug() {
+            let ns = NamespaceRegistry::new();
+            let config = make_spool_config(&ns);
+            let path = std::env::temp_dir().join(format!(
+                "fluree-spool-prefix-miss-{}.spool",
+                std::process::id()
+            ));
+            let mut ctx = SpoolContext::new(&path, 0, 0, &config).unwrap();
+            // A user-range code allocated outside the shared allocator.
+            let rogue = Sid::new(fluree_vocab::namespaces::USER_START, "name");
+            let _ = ctx.assign_predicate_id(&rogue);
+        }
+
         #[test]
         fn test_basic_iri_triple() {
             let mut ns = NamespaceRegistry::new();
@@ -959,9 +1011,13 @@ mod inner {
             let _ = std::fs::remove_dir_all(&dir);
             std::fs::create_dir_all(&dir).unwrap();
 
-            let mut ns = NamespaceRegistry::new();
+            let ns = NamespaceRegistry::new();
             let config = make_spool_config(&ns);
-            let mut sink = ImportSink::new(&mut ns, 1, "test-txn".to_string(), true).unwrap();
+            // Allocate through the config's shared allocator (production
+            // wiring) so spool prefix lookups resolve mid-parse.
+            let mut cache = WorkerCache::new(Arc::clone(&config.ns_alloc));
+            let mut sink =
+                ImportSink::new_cached(&mut cache, 1, "test-txn".to_string(), true).unwrap();
 
             // Attach spool context
             let spool_path = dir.join("chunk_0.spool");
@@ -1027,9 +1083,13 @@ mod inner {
             let _ = std::fs::remove_dir_all(&dir);
             std::fs::create_dir_all(&dir).unwrap();
 
-            let mut ns = NamespaceRegistry::new();
+            let ns = NamespaceRegistry::new();
             let config = make_spool_config(&ns);
-            let mut sink = ImportSink::new(&mut ns, 1, "test-txn".to_string(), true).unwrap();
+            // Allocate through the config's shared allocator (production
+            // wiring) so spool prefix lookups resolve mid-parse.
+            let mut cache = WorkerCache::new(Arc::clone(&config.ns_alloc));
+            let mut sink =
+                ImportSink::new_cached(&mut cache, 1, "test-txn".to_string(), true).unwrap();
 
             let spool_path = dir.join("chunk_0.spool");
             let spool_ctx = SpoolContext::new(&spool_path, 0, 0, &config).unwrap();
@@ -1075,9 +1135,13 @@ mod inner {
             let _ = std::fs::remove_dir_all(&dir);
             std::fs::create_dir_all(&dir).unwrap();
 
-            let mut ns = NamespaceRegistry::new();
+            let ns = NamespaceRegistry::new();
             let config = make_spool_config(&ns);
-            let mut sink = ImportSink::new(&mut ns, 1, "test-txn".to_string(), true).unwrap();
+            // Allocate through the config's shared allocator (production
+            // wiring) so spool prefix lookups resolve mid-parse.
+            let mut cache = WorkerCache::new(Arc::clone(&config.ns_alloc));
+            let mut sink =
+                ImportSink::new_cached(&mut cache, 1, "test-txn".to_string(), true).unwrap();
 
             let spool_path = dir.join("chunk_0.spool");
             let spool_ctx = SpoolContext::new(&spool_path, 0, 0, &config).unwrap();
diff --git a/fluree-db-transact/src/lib.rs b/fluree-db-transact/src/lib.rs
index 7b9f9d873..97bdb2554 100644
--- a/fluree-db-transact/src/lib.rs
+++ b/fluree-db-transact/src/lib.rs
@@ -65,7 +65,10 @@ pub use flake_sink::FlakeSink;
 pub use generate::{apply_cancellation, FlakeGenerator};
 pub use ir::{InlineValues, TemplateTerm, TripleTemplate, Txn, TxnOpts, TxnType};
 pub use lower_sparql_update::{lower_sparql_update, lower_sparql_update_ast, LowerError};
-pub use namespace::{NamespaceRegistry, SharedNamespaceAllocator, BLANK_NODE_PREFIX};
+pub use namespace::{
+    stable_blank_node_sid, stable_blank_node_sid_from_label, NamespaceRegistry,
+    SharedNamespaceAllocator, BLANK_NODE_PREFIX,
+};
 pub use parse::{
     parse_transaction, parse_trig_phase1, resolve_trig_meta, NamedGraphBlock, RawObject, RawTerm,
     RawTrigMeta, RawTriple, TrigPhase1Result,
diff --git a/fluree-db-transact/src/lower_sparql_update.rs b/fluree-db-transact/src/lower_sparql_update.rs
index 97e2c7872..b2011c9e7 100644
--- a/fluree-db-transact/src/lower_sparql_update.rs
+++ b/fluree-db-transact/src/lower_sparql_update.rs
@@ -1084,7 +1084,16 @@ fn subject_to_unresolved_delete_where(
     match term {
         SubjectTerm::Var(v) => Ok(UnresolvedTerm::Var(Arc::from(format!("?{}", v.name)))),
         SubjectTerm::Iri(iri) => Ok(UnresolvedTerm::Iri(Arc::from(expand_iri(iri, prologue)?))),
-        SubjectTerm::BlankNode(bn) => Ok(UnresolvedTerm::Var(bnodes.var_name(&bn.value))),
+        SubjectTerm::BlankNode(bn) => {
+            // Stable Fluree blank-node ids match the stored node as a
+            // constant; other labels act as existential variables (§3.1).
+            if let BlankNodeValue::Labeled(l) = &bn.value {
+                if crate::namespace::stable_blank_node_sid_from_label(l).is_some() {
+                    return Ok(UnresolvedTerm::Iri(Arc::from(format!("_:{l}"))));
+                }
+            }
+            Ok(UnresolvedTerm::Var(bnodes.var_name(&bn.value)))
+        }
         SubjectTerm::QuotedTriple(qt) => Err(LowerError::UnsupportedFeature {
             feature: "RDF-star quoted triple",
             span: qt.span,
@@ -1118,10 +1127,22 @@ fn object_to_unresolved_delete_where(
             dtc: None,
         }),
         Term::Literal(lit) => literal_to_unresolved(lit, prologue),
-        Term::BlankNode(bn) => Ok(UnresolvedTermWithMeta {
-            term: UnresolvedTerm::Var(bnodes.var_name(&bn.value)),
-            dtc: None,
-        }),
+        Term::BlankNode(bn) => {
+            // Stable Fluree blank-node ids match as constants
+            // (see subject_to_unresolved_delete_where).
+            if let BlankNodeValue::Labeled(l) = &bn.value {
+                if crate::namespace::stable_blank_node_sid_from_label(l).is_some() {
+                    return Ok(UnresolvedTermWithMeta {
+                        term: UnresolvedTerm::Iri(Arc::from(format!("_:{l}"))),
+                        dtc: None,
+                    });
+                }
+            }
+            Ok(UnresolvedTermWithMeta {
+                term: UnresolvedTerm::Var(bnodes.var_name(&bn.value)),
+                dtc: None,
+            })
+        }
     }
 }
 
@@ -1140,8 +1161,18 @@ fn lower_triple_to_delete_template_delete_where(
             TemplateTerm::Sid(ns.sid_for_iri(&expanded))
         }
         SubjectTerm::BlankNode(bn) => {
-            let name = bnodes.var_name(&bn.value);
-            TemplateTerm::Var(vars.get_or_insert(&name))
+            let stable = match &bn.value {
+                BlankNodeValue::Labeled(l) => crate::namespace::stable_blank_node_sid_from_label(l),
+                BlankNodeValue::Anon => None,
+            };
+            match stable {
+                // Stable Fluree blank-node ids retract from the stored node.
+                Some(sid) => TemplateTerm::Sid(sid),
+                None => {
+                    let name = bnodes.var_name(&bn.value);
+                    TemplateTerm::Var(vars.get_or_insert(&name))
+                }
+            }
         }
         SubjectTerm::QuotedTriple(qt) => {
             return Err(LowerError::UnsupportedFeature {
@@ -1175,8 +1206,17 @@ fn lower_triple_to_delete_template_delete_where(
             (r.term, r.dtc)
         }
         Term::BlankNode(bn) => {
-            let name = bnodes.var_name(&bn.value);
-            (TemplateTerm::Var(vars.get_or_insert(&name)), None)
+            let stable = match &bn.value {
+                BlankNodeValue::Labeled(l) => crate::namespace::stable_blank_node_sid_from_label(l),
+                BlankNodeValue::Anon => None,
+            };
+            match stable {
+                Some(sid) => (TemplateTerm::Sid(sid), None),
+                None => {
+                    let name = bnodes.var_name(&bn.value);
+                    (TemplateTerm::Var(vars.get_or_insert(&name)), None)
+                }
+            }
         }
     };
 
@@ -1283,7 +1323,15 @@ fn subject_to_template(
         }
         SubjectTerm::BlankNode(bn) => {
             let label = match &bn.value {
-                BlankNodeValue::Labeled(l) => format!("_:{l}"),
+                BlankNodeValue::Labeled(l) => {
+                    // Stable Fluree blank-node ids address the existing
+                    // stored node instead of skolemizing a fresh one, which
+                    // makes DELETE templates on them meaningful.
+                    if let Some(sid) = crate::namespace::stable_blank_node_sid_from_label(l) {
+                        return Ok(TemplateTerm::Sid(sid));
+                    }
+                    format!("_:{l}")
+                }
                 BlankNodeValue::Anon => bnodes.next(),
             };
             Ok(TemplateTerm::BlankNode(label))
@@ -1338,7 +1386,14 @@ fn object_to_template(
         Term::Literal(lit) => Ok(literal_to_template(lit, prologue, ns)?.term),
         Term::BlankNode(bn) => {
             let label = match &bn.value {
-                BlankNodeValue::Labeled(l) => format!("_:{l}"),
+                BlankNodeValue::Labeled(l) => {
+                    // Stable Fluree blank-node ids resolve to the stored node
+                    // (see subject_to_template).
+                    if let Some(sid) = crate::namespace::stable_blank_node_sid_from_label(l) {
+                        return Ok(TemplateTerm::Sid(sid));
+                    }
+                    format!("_:{l}")
+                }
                 BlankNodeValue::Anon => bnodes.next(),
             };
             Ok(TemplateTerm::BlankNode(label))
diff --git a/fluree-db-transact/src/namespace.rs b/fluree-db-transact/src/namespace.rs
index 6f9499785..6da42edfd 100644
--- a/fluree-db-transact/src/namespace.rs
+++ b/fluree-db-transact/src/namespace.rs
@@ -590,6 +590,28 @@ pub fn is_blank_node_id(iri: &str) -> bool {
     iri.starts_with("_:fdb")
 }
 
+/// Resolve a stable Fluree blank-node identifier (`_:fdb-...`) directly to
+/// its stored Sid, bypassing skolemization so writes address the existing
+/// node instead of minting a fresh one. Returns `None` for ordinary blank
+/// node labels (fresh-mint semantics) and non-blank-node strings.
+///
+/// Call sites should be at parse/lowering time (once per term), never in
+/// per-solution template instantiation.
+#[inline]
+pub fn stable_blank_node_sid(iri: &str) -> Option<Sid> {
+    fluree_db_core::ns_encoding::stable_blank_node_local(iri)
+        .map(|local| Sid::new(BLANK_NODE, local))
+}
+
+/// Like [`stable_blank_node_sid`] but for a bare label with the `_:` already
+/// stripped (e.g. Turtle parser output).
+#[inline]
+pub fn stable_blank_node_sid_from_label(label: &str) -> Option<Sid> {
+    label
+        .starts_with(fluree_db_core::ns_encoding::STABLE_BLANK_NODE_LABEL_PREFIX)
+        .then(|| Sid::new(BLANK_NODE, label))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -656,6 +678,32 @@ mod tests {
         assert!(!is_blank_node_id("http://example.org/thing"));
     }
 
+    #[test]
+    fn test_stable_blank_node_sid() {
+        // A stable id round-trips to the exact Sid blank_node_sid minted.
+        let registry = NamespaceRegistry::new();
+        let minted = registry.blank_node_sid("1234-0-b0");
+        let resolved = stable_blank_node_sid("_:fdb-1234-0-b0").expect("stable id resolves");
+        assert_eq!(resolved, minted);
+
+        // Ordinary labels and non-blank strings do not resolve.
+        assert!(stable_blank_node_sid("_:b0").is_none());
+        assert!(stable_blank_node_sid("_:fdbx").is_none()); // reserved form requires `fdb-`
+        assert!(stable_blank_node_sid("http://example.org/fdb-1").is_none());
+    }
+
+    #[test]
+    fn test_stable_blank_node_sid_from_label() {
+        let registry = NamespaceRegistry::new();
+        let minted = registry.blank_node_sid("1234-0-b0");
+        assert_eq!(
+            stable_blank_node_sid_from_label("fdb-1234-0-b0"),
+            Some(minted)
+        );
+        assert!(stable_blank_node_sid_from_label("b0").is_none());
+        assert!(stable_blank_node_sid_from_label("fdbx").is_none());
+    }
+
     #[test]
     fn test_sid_for_iri_canonical_split() {
         let mut registry = NamespaceRegistry::new();
diff --git a/fluree-db-transact/src/parse/edge_annotations.rs b/fluree-db-transact/src/parse/edge_annotations.rs
index b78431ff0..51ac81ca8 100644
--- a/fluree-db-transact/src/parse/edge_annotations.rs
+++ b/fluree-db-transact/src/parse/edge_annotations.rs
@@ -1060,17 +1060,16 @@ fn build_annotation_delete(
         .map(String::from);
 
     let template_id: String = if let Some(ann_id) = explicit_id {
-        // Reject blank-node @ids: a user can't legitimately pin a
-        // specific anonymous annotation by its blank-node id (those
-        // are minted server-side at insert time). If they really
-        // want to retract an anonymous annotation, they should use
-        // the selector form (no @id) and let the WHERE clause
-        // resolve it.
-        if ann_id.starts_with("_:") {
+        // Reject client-authored blank-node @ids: those are skolemized
+        // fresh at insert time, so they can't pin an existing annotation.
+        // Stable Fluree ids (`_:fdb-...`, obtained from a query) DO denote
+        // the stored node and pass through to the delete template.
+        if ann_id.starts_with("_:") && crate::namespace::stable_blank_node_sid(&ann_id).is_none() {
             return Err(TransactError::UnsupportedFeature(
-                "delete by anonymous annotation @id is not supported — anonymous SIDs \
-                 are minted at insert time and not user-addressable. Use a selector \
-                 form (no @id, body properties only) or attach an explicit @id at insert."
+                "delete by anonymous annotation @id is not supported — client blank-node \
+                 labels are minted fresh at insert time and not user-addressable. Use the \
+                 stable `_:fdb-...` id returned by a query, a selector form (no @id, body \
+                 properties only), or attach an explicit @id at insert."
                     .to_string(),
             ));
         }
diff --git a/fluree-db-transact/src/parse/jsonld.rs b/fluree-db-transact/src/parse/jsonld.rs
index 1765a9737..765a45ad9 100644
--- a/fluree-db-transact/src/parse/jsonld.rs
+++ b/fluree-db-transact/src/parse/jsonld.rs
@@ -1125,6 +1125,11 @@ fn parse_values_cell(
                 let (expanded, _) =
                     fluree_graph_json_ld::details_with_policy(id_str, context, strict)?;
                 if expanded.starts_with("_:") {
+                    // Stable Fluree blank-node ids address the existing node;
+                    // other labels keep fresh-mint skolemization semantics.
+                    if let Some(sid) = crate::namespace::stable_blank_node_sid(&expanded) {
+                        return Ok(TemplateTerm::Sid(sid));
+                    }
                     return Ok(TemplateTerm::BlankNode(expanded.to_string()));
                 }
                 return Ok(TemplateTerm::Sid(ns_registry.sid_for_iri(&expanded)));
@@ -1348,7 +1353,11 @@ fn parse_expanded_id_with_ctx(
                 let var_id = ctx.vars.get_or_insert(s);
                 Ok(TemplateTerm::Var(var_id))
             } else if s.starts_with("_:") {
-                // Blank node
+                // Stable Fluree blank-node ids resolve to the existing node;
+                // other labels stay BlankNode for fresh-mint skolemization.
+                if let Some(sid) = crate::namespace::stable_blank_node_sid(s) {
+                    return Ok(TemplateTerm::Sid(sid));
+                }
                 Ok(TemplateTerm::BlankNode(s.clone()))
             } else {
                 // Expanded IRI - encode as SID
diff --git a/testsuite-sparql/Cargo.lock b/testsuite-sparql/Cargo.lock
index 5c83d6b00..3a632ecdf 100644
--- a/testsuite-sparql/Cargo.lock
+++ b/testsuite-sparql/Cargo.lock
@@ -697,6 +697,7 @@ dependencies = [
  "indexmap",
  "itoa",
  "moka",
+ "parking_lot",
  "percent-encoding",
  "rustc-hash",
  "ryu",
@@ -879,6 +880,7 @@ dependencies = [
  "fluree-db-novelty",
  "fluree-vocab",
  "futures",
+ "parking_lot",
  "serde_json",
  "thiserror 1.0.69",
  "tracing",