emem-langmem 1.2.1__tar.gz

emem_langmem-1.2.1/.gitignore

@@ -0,0 +1,91 @@
+# Rust build artefacts
+/target/
+**/target/
+
+# Local persisted data + secrets
+/var/
+**/var/emem/
+**/var/demos/
+*.secret.b32
+identity.secret.b32
+.cloudflared/
+acme.cache/
+tls/
+# Runtime cruft — when EMEM_DATA=:memory: is misinterpreted as a path
+# string, a literal :memory: directory is created. Untracked but
+# silenced from `git status` so it doesn't read as repo state.
+/:memory:/
+**/:memory:/
+
+# Editor / OS
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Node / Vite — the old TS/Vite SPA at repo root was retired in 0.0.6;
+# the live https://emem.dev is served by the Rust `emem-server` binary.
+# These patterns prevent the scaffolding from sneaking back in at root.
+# sdks/emem-ts/ has its own legitimate package.json / tsconfig.json /
+# src/ — those are NOT matched here because patterns are anchored to /.
+#
+# Anchoring only holds for git. hatchling re-anchors a root-anchored
+# pattern to whatever directory it is building, so `/src/` here also hit
+# `sdks/emem-py/src` and `sdks/emem-langmem/src`, and both wheels built
+# clean with zero modules in them. ememdev 1.0.0 shipped to PyPI that
+# way: metadata only, `import emem` raised ModuleNotFoundError. Keep
+# root-anchored patterns off any directory name an SDK also uses.
+node_modules/
+dist/
+dist-server/
+.parcel-cache/
+/index.html
+/package-lock.json
+/vite.config.ts
+/tsconfig.server.json
+/server/
+/tests/*.test.ts
+
+# Artifacts (screenshots, generated images) — keep folder, ignore contents
+
+# Python ad-hoc tools
+__pycache__/
+*.pyc
+.venv/
+
+# Local Claude / IDE state
+.claude/
+CLAUDE.md
+registry_claude.md
+
+# Env files
+.env
+.env.*
+!.env.example
+
+# Logs + coverage
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+coverage/
+.nyc_output/
+notes/
+
+# fastembed-rs ONNX model cache (HF hub mirror, ~400 MB)
+.fastembed_cache/
+scripts/eval/results/q*.json
+
+# mdbook output for the /docs/ site. The book is built at deploy/CI time
+# (see scripts/redeploy.sh and .github/workflows/ci.yml) and baked into
+# the binary via `include_dir!("docs/book")`. Committing it would churn the
+# repo every docs edit (hashed asset filenames) and add ~5 MB; build it
+# fresh on each CI run instead.
+docs/book/
+
+# 3d-worlds exporter output (samples live under examples/3d-worlds/scenes/)
+examples/3d-worlds/out/
+
+# Agent scratch notes belong in .well-known/agent-notes/, never the repo root.
+/AGENT_*.md

emem_langmem-1.2.1/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: emem-langmem
+Version: 1.2.1
+Summary: LangChain BaseStore backed by emem.dev — drop-in agent memory for LangGraph
+Project-URL: Homepage, https://emem.dev
+Project-URL: Repository, https://github.com/Vortx-AI/emem
+Project-URL: Documentation, https://emem.dev/docs/sdks/langmem.html
+Project-URL: Issues, https://github.com/Vortx-AI/emem/issues
+Author-email: Vortx AI Private Limited <avijeet@vortx.ai>
+License: Apache-2.0
+Keywords: agent-memory,content-addressed,ed25519,langchain,langgraph,langmem,mcp,verifiable
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Requires-Dist: blake3>=0.3
+Requires-Dist: cryptography>=41
+Requires-Dist: httpx>=0.27
+Requires-Dist: langchain-core<1.0,>=0.3
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
+Requires-Dist: pytest>=8.0; extra == 'test'
+Requires-Dist: respx>=0.21; extra == 'test'
+Description-Content-Type: text/markdown
+
+# emem-langmem
+
+LangChain `BaseStore` backed by [emem.dev](https://emem.dev) — drop-in
+agent memory for LangGraph with ed25519 receipts and content-addressed
+recall.
+
+## Install
+
+```bash
+pip install emem-langmem
+```
+
+## Use
+
+```python
+from emem_langmem import EmemStore
+from langgraph.graph import StateGraph
+
+store = EmemStore(base_url="https://emem.dev", signing_key=SEED)
+
+graph = StateGraph(...).compile(store=store)
+```
+
+`SEED` is a raw 32-byte ed25519 seed that you own and persist, for
+example `os.urandom(32)` once, then kept wherever the agent's other
+secrets live. It signs every write, and the responder requires that:
+an unattested write is refused unless the operator opened the responder
+with `EMEM_MEMORY_OPEN=1`. The key also decides where the store writes.
+
+`EmemStore` implements the four `BaseStore` verbs by issuing MCP
+`tools/call` requests to the emem responder against the six Anthropic
+memory-tool verbs:
+
+| BaseStore verb | emem MCP tool   | Signed |
+|----------------|-----------------|--------|
+| `mget(keys)`   | `memory_view`   | read, no signature |
+| `mset(pairs)`  | `memory_create` | yes |
+| `mdelete(ks)`  | `memory_delete` | yes |
+| `yield_keys`   | `memory_view` (directory walk) | read, no signature |
+
+## Namespaces
+
+With a signing key, the store roots itself at
+`/memories/by_attester/<pubkey8>/`, where `<pubkey8>` is the first 8
+characters of your base32 pubkey. Only that key can write there, so
+agents sharing one responder cannot overwrite each other. LangChain
+calls `mget(("ns","key"))` and the store reads
+`/memories/by_attester/<pubkey8>/ns/key`.
+
+```python
+store.root              # '/memories/by_attester/aoqqpp7t'
+store.signer.pubkey_b32 # the full base32 pubkey
+```
+
+A key that starts with `/` is taken as a literal absolute path and is
+left alone, which is how you reach outside your own root. Writing into
+another key's namespace is refused with a 403. Without a signing key the
+root stays `/memories` and writes go out unattested. See
+[docs/memory.md](https://emem.dev/docs/memory.md) for the wire format.
+
+`EmemSigner` is public if you drive the memory tools yourself and need
+the same `attester` block:
+
+```python
+from emem_langmem import EmemSigner
+
+signer = EmemSigner(SEED)
+signer.attester_block("create", f"{signer.namespace_root}/n.md", b"hi")
+# {'pubkey_b32': '...', 'sig_b32': '...'}
+```
+
+Async variants `amget` / `amset` / `amdelete` / `ayield_keys` are
+implemented over `httpx.AsyncClient`.
+
+## Self-host
+
+```python
+EmemStore(base_url="http://127.0.0.1:5051")
+```
+
+or set `EMEM_BASE_URL` in the environment.
+
+## Receipts
+
+Every read and write returns an ed25519 receipt from the emem responder.
+The receipt is currently dropped at the `BaseStore` interface boundary
+(LangChain's contract has no receipt slot). To inspect receipts, call
+the underlying MCP tool directly:
+
+```python
+import json, httpx, uuid
+r = httpx.post(
+    "https://emem.dev/mcp",
+    json={
+        "jsonrpc": "2.0",
+        "id": str(uuid.uuid4()),
+        "method": "tools/call",
+        "params": {
+            "name": "memory_view",
+            "arguments": {"path": "/memories/my/note.txt"},
+        },
+    },
+).json()
+print(r["result"]["structuredContent"]["receipt"])
+```
+
+## License
+
+Apache-2.0.

emem_langmem-1.2.1/README.md

@@ -0,0 +1,109 @@
+# emem-langmem
+
+LangChain `BaseStore` backed by [emem.dev](https://emem.dev) — drop-in
+agent memory for LangGraph with ed25519 receipts and content-addressed
+recall.
+
+## Install
+
+```bash
+pip install emem-langmem
+```
+
+## Use
+
+```python
+from emem_langmem import EmemStore
+from langgraph.graph import StateGraph
+
+store = EmemStore(base_url="https://emem.dev", signing_key=SEED)
+
+graph = StateGraph(...).compile(store=store)
+```
+
+`SEED` is a raw 32-byte ed25519 seed that you own and persist, for
+example `os.urandom(32)` once, then kept wherever the agent's other
+secrets live. It signs every write, and the responder requires that:
+an unattested write is refused unless the operator opened the responder
+with `EMEM_MEMORY_OPEN=1`. The key also decides where the store writes.
+
+`EmemStore` implements the four `BaseStore` verbs by issuing MCP
+`tools/call` requests to the emem responder against the six Anthropic
+memory-tool verbs:
+
+| BaseStore verb | emem MCP tool   | Signed |
+|----------------|-----------------|--------|
+| `mget(keys)`   | `memory_view`   | read, no signature |
+| `mset(pairs)`  | `memory_create` | yes |
+| `mdelete(ks)`  | `memory_delete` | yes |
+| `yield_keys`   | `memory_view` (directory walk) | read, no signature |
+
+## Namespaces
+
+With a signing key, the store roots itself at
+`/memories/by_attester/<pubkey8>/`, where `<pubkey8>` is the first 8
+characters of your base32 pubkey. Only that key can write there, so
+agents sharing one responder cannot overwrite each other. LangChain
+calls `mget(("ns","key"))` and the store reads
+`/memories/by_attester/<pubkey8>/ns/key`.
+
+```python
+store.root              # '/memories/by_attester/aoqqpp7t'
+store.signer.pubkey_b32 # the full base32 pubkey
+```
+
+A key that starts with `/` is taken as a literal absolute path and is
+left alone, which is how you reach outside your own root. Writing into
+another key's namespace is refused with a 403. Without a signing key the
+root stays `/memories` and writes go out unattested. See
+[docs/memory.md](https://emem.dev/docs/memory.md) for the wire format.
+
+`EmemSigner` is public if you drive the memory tools yourself and need
+the same `attester` block:
+
+```python
+from emem_langmem import EmemSigner
+
+signer = EmemSigner(SEED)
+signer.attester_block("create", f"{signer.namespace_root}/n.md", b"hi")
+# {'pubkey_b32': '...', 'sig_b32': '...'}
+```
+
+Async variants `amget` / `amset` / `amdelete` / `ayield_keys` are
+implemented over `httpx.AsyncClient`.
+
+## Self-host
+
+```python
+EmemStore(base_url="http://127.0.0.1:5051")
+```
+
+or set `EMEM_BASE_URL` in the environment.
+
+## Receipts
+
+Every read and write returns an ed25519 receipt from the emem responder.
+The receipt is currently dropped at the `BaseStore` interface boundary
+(LangChain's contract has no receipt slot). To inspect receipts, call
+the underlying MCP tool directly:
+
+```python
+import json, httpx, uuid
+r = httpx.post(
+    "https://emem.dev/mcp",
+    json={
+        "jsonrpc": "2.0",
+        "id": str(uuid.uuid4()),
+        "method": "tools/call",
+        "params": {
+            "name": "memory_view",
+            "arguments": {"path": "/memories/my/note.txt"},
+        },
+    },
+).json()
+print(r["result"]["structuredContent"]["receipt"])
+```
+
+## License
+
+Apache-2.0.

emem_langmem-1.2.1/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["hatchling>=1.18"]
+build-backend = "hatchling.build"
+
+[project]
+name = "emem-langmem"
+version = "1.2.1"
+description = "LangChain BaseStore backed by emem.dev — drop-in agent memory for LangGraph"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Apache-2.0" }
+authors = [
+    { name = "Vortx AI Private Limited", email = "avijeet@vortx.ai" },
+]
+keywords = [
+    "langchain",
+    "langgraph",
+    "langmem",
+    "mcp",
+    "agent-memory",
+    "verifiable",
+    "ed25519",
+    "content-addressed",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "langchain-core>=0.3,<1.0",
+    "httpx>=0.27",
+    # Attester signing on every memory write: blake3 builds the preimage,
+    # cryptography holds the ed25519 key. Both mirror what the responder
+    # verifies (crates/emem-primitives/src/memory_acl.rs).
+    "blake3>=0.3",
+    "cryptography>=41",
+]
+
+[project.urls]
+Homepage      = "https://emem.dev"
+Repository    = "https://github.com/Vortx-AI/emem"
+Documentation = "https://emem.dev/docs/sdks/langmem.html"
+Issues        = "https://github.com/Vortx-AI/emem/issues"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "respx>=0.21",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/emem_langmem"]

emem_langmem-1.2.1/src/emem_langmem/__init__.py

@@ -0,0 +1,44 @@
+"""LangChain BaseStore backed by emem.dev.
+
+A LangGraph agent gets verifiable, ed25519-signed agent memory in one
+line, plus the key it signs with:
+
+    from emem_langmem import EmemStore
+    store = EmemStore(base_url="https://emem.dev", signing_key=SEED)
+    graph = StateGraph(...).compile(store=store)
+
+`SEED` is a raw 32-byte ed25519 seed the caller owns and persists. It
+does two things. It signs every write, which the responder requires:
+an unattested write is refused unless the operator opened the responder
+with `EMEM_MEMORY_OPEN=1`. And it roots the store at
+`/memories/by_attester/<pubkey8>/`, the namespace only that key can
+write to, so agents sharing one responder cannot overwrite each other.
+Lose the seed and you lose write access to that namespace, so keep it
+where the agent's other secrets live.
+
+`EmemStore` implements the four `BaseStore` verbs (`mget`, `mset`,
+`mdelete`, `yield_keys`) by issuing MCP `tools/call` requests to the
+emem responder against the six Anthropic memory-tool verbs (`memory_view`,
+`memory_create`, `memory_str_replace`, `memory_insert`, `memory_delete`,
+`memory_rename`). Every write is content-addressed and countersigned by
+the responder; every read carries a receipt verifiable offline at the
+responder's `/verify` page.
+
+`EmemSigner` is public for callers who drive the memory tools directly
+and need the same `attester` block.
+"""
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+from emem_langmem.signing import EmemSigner
+from emem_langmem.store import EmemAttestationError, EmemStore, EmemStoreError
+
+__all__ = ["EmemStore", "EmemSigner", "EmemStoreError", "EmemAttestationError"]
+
+# Single source of truth: the installed distribution's version, which comes
+# from pyproject.toml. Keeps __version__ and the store's User-Agent from
+# drifting out of sync with what actually ships to PyPI.
+try:
+    __version__ = _pkg_version("emem-langmem")
+except PackageNotFoundError:  # running from a source checkout, not installed
+    __version__ = "0+unknown"

emem_langmem-1.2.1/src/emem_langmem/signing.py

@@ -0,0 +1,231 @@
+"""ed25519 attester signing for emem memory writes.
+
+The emem responder gates every memory write verb (`create`,
+`str_replace`, `insert`, `delete`, `rename`) behind an `attester`
+block. The block binds the write to an ed25519 key:
+
+    sig = ed25519(blake3(b"emem.memory_write|" + verb + b"|"
+                         + path + b"|" + body_hash))
+
+and travels on the wire as::
+
+    "attester": {"pubkey_b32": "<52 chars>", "sig_b32": "<103 chars>"}
+
+Both fields are base32-nopad, lowercase. The preimage shape is fixed so
+a client signs offline with no server round-trip. This module mirrors
+`crates/emem-primitives/src/memory_acl.rs`; the function names match the
+Rust (`attester_preimage`, `body_hash`, `rename_body_hash`,
+`pubkey_short_from_b32`) so the two sides can be read side by side.
+
+`body_hash` is blake3 over the bytes the responder itself hashes, which
+is not always the bytes a caller thinks it is sending:
+
+| verb          | body the responder hashes                        |
+|---------------|--------------------------------------------------|
+| `create`      | UTF-8 bytes of the `file_text` string sent        |
+| `str_replace` | UTF-8 bytes of the whole file *after* the edit    |
+| `insert`      | UTF-8 bytes of the whole file *after* the insert  |
+| `delete`      | empty (blake3 of b"")                             |
+| `rename`      | UTF-8 bytes of the `old_path` string              |
+
+So `str_replace` and `insert` cannot be signed without knowing the
+file's current content: read it, apply the edit locally, and sign the
+result.
+
+`rename` is the one verb whose preimage `path` is not the path the
+caller names first. The destination rides `path` and the source rides
+the body, so one signature binds both ends of the move. Use
+`EmemSigner.rename_attester_block`, which puts them in the right slots.
+The responder cannot check the signature against the source (that would
+be one signature against two messages), so it answers the source as a
+namespace question instead: the key must own both ends.
+
+Writes under `/memories/by_attester/<pubkey8>/...` are restricted to the
+holder of the matching private key, where `<pubkey8>` is the first 8
+characters of the lowercased base32 pubkey. A signed write aimed at
+another key's namespace is refused with a 403.
+"""
+
+from __future__ import annotations
+
+import base64
+from typing import Union
+
+from blake3 import blake3
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+# Mirrors emem_primitives::BY_ATTESTER_PREFIX / PUBKEY_SHORT_LEN.
+BY_ATTESTER_PREFIX = "/memories/by_attester/"
+PUBKEY_SHORT_LEN = 8
+
+#: The five memory-tool write verbs the responder will verify a
+#: signature for. `memory_view` is a read and carries no attester.
+WRITE_VERBS = ("create", "str_replace", "insert", "delete", "rename")
+
+_PREIMAGE_TAG = b"emem.memory_write|"
+_SEP = b"|"
+
+
+def b32_nopad_lc(raw: bytes) -> str:
+    """Encode bytes the way the responder expects: base32, no padding,
+    lowercase."""
+    return base64.b32encode(raw).decode("ascii").rstrip("=").lower()
+
+
+def body_hash(body: bytes = b"") -> bytes:
+    """blake3 of the write body, as 32 raw bytes. `delete` carries no
+    body and hashes the empty string, which is the default. `rename`
+    carries its source path: see `rename_body_hash`."""
+    return blake3(body).digest()
+
+
+def rename_body_hash(old_path: str) -> bytes:
+    """The body-hash for a `rename`: blake3 over the *source* path's
+    UTF-8 bytes.
+
+    The destination already rides the preimage's `path` component, so
+    hashing the source here makes one signature bind both ends of the
+    move.
+    """
+    return body_hash(old_path.encode("utf-8"))
+
+
+def attester_preimage(verb: str, path: str, body_digest: bytes) -> bytes:
+    """Build the 32-byte digest that gets signed.
+
+    `body_digest` is the 32 raw bytes from `body_hash`, not the body.
+    """
+    if verb not in WRITE_VERBS:
+        raise ValueError(f"unknown write verb {verb!r}; expected one of {', '.join(WRITE_VERBS)}")
+    if len(body_digest) != 32:
+        raise ValueError(f"body_digest must be 32 bytes, got {len(body_digest)}")
+    h = blake3()
+    h.update(_PREIMAGE_TAG)
+    h.update(verb.encode("utf-8"))
+    h.update(_SEP)
+    h.update(path.encode("utf-8"))
+    h.update(_SEP)
+    h.update(body_digest)
+    return h.digest()
+
+
+def pubkey_short_from_b32(pubkey_b32: str) -> str:
+    """First 8 chars of the lowercased base32 pubkey: the segment the
+    responder matches against `/memories/by_attester/<pubkey8>/...`."""
+    return pubkey_b32.lower()[:PUBKEY_SHORT_LEN]
+
+
+class EmemSigner:
+    """Signs emem memory writes with an ed25519 key.
+
+    The key comes from the caller. Nothing here generates one, and there
+    is no fallback key: an `EmemSigner` without a real private key would
+    write into a namespace the caller cannot reclaim.
+
+    Parameters
+    ----------
+    private_key:
+        The raw 32-byte ed25519 seed (what `cryptography` calls the
+        private bytes, and what the Rust side calls
+        `SigningKey::from_bytes`). Use `from_hex` for a 64-char hex seed.
+
+    Example
+    -------
+    >>> import os
+    >>> signer = EmemSigner(os.urandom(32))          # persist this seed
+    >>> block = signer.attester_block("create", f"{signer.namespace_root}/n.md", b"hi")
+    >>> sorted(block)
+    ['pubkey_b32', 'sig_b32']
+    """
+
+    def __init__(self, private_key: bytes) -> None:
+        if isinstance(private_key, str):
+            raise TypeError(
+                "private_key must be the raw 32-byte seed, not a string; "
+                "use EmemSigner.from_hex() for a hex seed"
+            )
+        if not isinstance(private_key, (bytes, bytearray)):
+            raise TypeError(f"private_key must be bytes, got {type(private_key).__name__}")
+        if len(private_key) != 32:
+            raise ValueError(f"ed25519 private key must be 32 bytes, got {len(private_key)}")
+        self._key = Ed25519PrivateKey.from_private_bytes(bytes(private_key))
+        self.pubkey: bytes = self._key.public_key().public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw,
+        )
+        self.pubkey_b32: str = b32_nopad_lc(self.pubkey)
+        self.pubkey_short: str = pubkey_short_from_b32(self.pubkey_b32)
+
+    @classmethod
+    def from_hex(cls, seed_hex: str) -> "EmemSigner":
+        """Build a signer from a 64-character hex ed25519 seed."""
+        try:
+            raw = bytes.fromhex(seed_hex.strip())
+        except ValueError as e:
+            raise ValueError(f"seed_hex is not valid hex: {e}") from e
+        return cls(raw)
+
+    @property
+    def namespace_root(self) -> str:
+        """This key's own memory namespace: `/memories/by_attester/<pubkey8>`."""
+        return f"{BY_ATTESTER_PREFIX}{self.pubkey_short}"
+
+    def sign_preimage(self, preimage: bytes) -> bytes:
+        """Raw ed25519 signature (64 bytes) over an already-built preimage."""
+        return self._key.sign(preimage)
+
+    def attester_block(self, verb: str, path: str, body: bytes = b"") -> dict:
+        """Build the wire `attester` block for one write.
+
+        `body` is the byte string the responder will hash for this verb
+        (see the table in this module's docstring). It defaults to empty,
+        which is right for `delete`. For `rename`, prefer
+        `rename_attester_block`.
+        """
+        digest = attester_preimage(verb, path, body_hash(body))
+        return {
+            "pubkey_b32": self.pubkey_b32,
+            "sig_b32": b32_nopad_lc(self.sign_preimage(digest)),
+        }
+
+    def rename_attester_block(self, old_path: str, new_path: str) -> dict:
+        """Build the wire `attester` block for a `rename`.
+
+        The preimage's `path` is the destination and its body is the
+        source, which is easy to invert by hand. Pass the paths in the
+        same order `memory_rename` takes them and this puts them in the
+        right slots.
+
+        The responder additionally requires this key to own both ends of
+        the move; it refuses a source in another key's namespace with a
+        403. Signing here does not check that.
+        """
+        return {
+            "pubkey_b32": self.pubkey_b32,
+            "sig_b32": b32_nopad_lc(
+                self.sign_preimage(
+                    attester_preimage("rename", new_path, rename_body_hash(old_path))
+                )
+            ),
+        }
+
+    def owns(self, path: str) -> bool:
+        """Whether `path` sits in this key's attester namespace. Paths
+        outside `/memories/by_attester/` are not owned by anyone, so they
+        return False."""
+        rest = path[len(BY_ATTESTER_PREFIX) :] if path.startswith(BY_ATTESTER_PREFIX) else None
+        if rest is None:
+            return False
+        return rest.split("/", 1)[0] == self.pubkey_short
+
+    def __repr__(self) -> str:
+        # Never render private bytes.
+        return f"EmemSigner(pubkey_short={self.pubkey_short!r})"
+
+
+def coerce_signer(signing_key: Union["EmemSigner", bytes, bytearray, None]) -> "EmemSigner":
+    """Accept either a ready `EmemSigner` or a raw 32-byte seed."""
+    if isinstance(signing_key, EmemSigner):
+        return signing_key
+    return EmemSigner(signing_key)  # type: ignore[arg-type]