Struct Namespace 

pub struct Namespace { /* private fields */ }

Hierarchical key prefix for memory operations.

tenant_id segments out per-customer data. scope adds nested dimensions — typically [agent_id, conversation_id] for chat-style agents.

Implementations

impl Namespace

pub const fn new(tenant_id: TenantId) -> Self

Build a namespace bound to tenant_id. The mandatory argument is the F2 mitigation in code form — there is no other way to obtain a Namespace. The TenantId argument has already passed its validating constructor, so cross-tenant collapse (":scope" instead of "acme:scope") is structurally impossible at this surface.

pub fn with_scope(self, segment: impl Into<String>) -> Self

Append one scope segment. Builder-style.

pub const fn tenant_id(&self) -> &TenantId

Borrow the tenant identifier.

pub fn scope(&self) -> &[String]

Borrow the scope segments in registration order.

pub fn render(&self) -> String

Render the namespace as a flat :-separated key, useful for backends that take a single string per row. Segments containing : or \ are escaped (\: and \\) so two distinct namespaces can never collide on the rendered key.

pub fn parse(rendered: &str) -> Result<Self>

Inverse of Self::render. Decodes a flat :-separated key back into a typed Namespace, honouring the same escape rules (\: for : inside a segment, \\ for \). Round-trip property: Namespace::parse(&ns.render()) == Ok(ns.clone()) for every well-formed namespace.

The motivating consumer is the audit channel (invariant #18): GraphEvent::MemoryRecall::namespace_key carries rendered keys, and operators replaying the log recover the typed scope (tenant boundary, agent / conversation dimensions) by parsing.

Rejects:

• leading : (e.g. ":scope") — empty tenant component, surfaces as Error::InvalidRequest via the TenantId::try_from validator. Invariant 11 — a tenantless Namespace would silently collapse every tenant onto a single rendered key prefix.
• trailing lone \ (incomplete escape) — surfaces as Error::InvalidRequest.
• \<x> for x other than : or \ — unknown escape, same error variant. Round-tripping a namespace that never contained : or \ cannot produce these inputs; they only arise from hand-crafted (invalid) keys.

Trait Implementations

impl Clone for Namespace

fn clone(&self) -> Namespace

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Namespace

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Namespace

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Namespace> for NamespacePrefix

fn from(ns: &Namespace) -> Self

Converts to this type from the input type.

impl Hash for Namespace

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Namespace

fn eq(&self, other: &Namespace) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Namespace

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Namespace

impl StructuralPartialEq for Namespace