Skip to content

RFC-0032 — One name for a thing, and one parser that reads it

  • Status: Draft
  • Track: I27
  • Relates to:
    • RFC-0005 (which declared the yidam:// scheme normative for MCP resources; §4.1 amends that section rather than contradicting it)
    • RFC-0019 (whose cites: is the only identifier in the system that can name a foreign node at a known revision, and which is a struct rather than a string)
    • RFC-0027 (whose §5 argued that a url a reader follows cannot be a yidam:// URI, and whose public_base this generalises off one profile)
    • RFC-0008 (which measured that a claim has no identity a checker can read; §4.4 is that result written into the grammar as a refusal)
    • RFC-0031 (whose node-prose work owns the scope half of the evidence-tag request; this owns the provenance half)
  • Versioning layers touched: SDK+parity (one parser, three languages) / tooling (every surface that builds or splits an id) / MCP contract (§4.1 adds a slot to the resource namespace — a minor bump, in all three copies). No on-disk format change: links: and cites: keep their shapes.
  • Amended 2026-09-09 (#777): the precondition below is weaker than this RFC first claimed, and §4.1 and §4.6 move with it. Two of sixteen measured corpora do not satisfy it, so the parser reports conformance instead of assuming it.
  • Precondition, landed: name-not-a-slug (#775). A grammar over names cannot be specified while a name may contain a space; that check makes the character set an invariant of a corpus that passes lint — which is not every corpus. See the amendment in §4.1.
  • Downstream reference case: goedelsoup/ohio-education-funding (129 nodes, 168 crate references folded into evidence-tag details). The tag measurements below are over thirteen corpora, on maturity grounds; §4.1's conformance measurement is over all sixteen with tracked nodes, because that question is about adoption rather than practice

Summary

A corpus node has eleven string forms across this repository. Two of them can say which corpus a node came from, one can say which revision, and none can say both. The forms are not alternatives a caller chooses between — they are what different surfaces invented independently because there was no first form to reuse, and one of them, find_node, already accepts three spellings that no contract mentions. An ad-hoc resolver is what an absent grammar looks like from the inside.

The absence has a second face. A derived corpus folded 168 crate paths and 145 catalog and node references into evidence-tag details, because the tag bracket was the only place a reference could be written at all, and then grew a regex to read them back out. Measured across thirteen derived corpora, ~89% of those details name a source rather than qualifying a claim. That is not a tag problem wearing a reference costume; it is this problem, reported from a corpus.

So: one grammar, rendered two ways. A yidam:// identifier that works inside a .yiz tarball with no host, and an https:// locator for anything a stranger has to follow. One parser on the parity surface, and it becomes the only place an identifier is built or split.

Problem

1 — The scheme spends its authority on the collection

yidam://corpus/<class>/<name> parses, under RFC 3986, as authority corpus and path /<class>/<name>. The naming authority slot — the one component whose job is to say who names this — holds a collection kind. yidam://graph/summary, yidam://skills/<name> and yidam://decisions/<name> do the same with three more kinds. There is nowhere left to put a corpus.

That is not a latent tidiness issue. resources.rs:56 interpolates node.id into the URI, and the loop it sits in reads state.nodes only — dep_nodes is a separate field by deliberate design. So a dependency node has no resource URI at all, while find_any_node reads one happily by its qualified id. One server answers a question through its tool surface that its resource surface cannot address, and RFC-0005 declares the scheme normative without mentioning dependencies.

2 — The RDF export mints subjects in a scheme nothing can dereference

instance_iri types every instance at yidam://corpus/<class>/<name> and dataset_iri names the dataset with a bare authority. No RDF consumer can follow either, and two corpora holding concept/foo mint the same subject. The export already knows the distinction it is failing to apply: export_rdf.rs:317 tests a foreign alignment IRI for a scheme it can dereference and demotes it to a literal when it fails. It applies that test to other people's IRIs and not to its own.

Separately, YIDAM_NS was https://yidam.dev/ontology#, and that domain does not resolve — curl answers 000, not 404. It shipped in every corpus's exported triples, which is worse than a dead link: an unowned namespace already published in other people's data is registrable by a stranger, who would then be authoritative for terms this project minted.

Resolved 2026-09-09 (P3). Both halves. The namespace moved to https://goedelsoup.github.io/yidam/ontology#, the one origin with a demonstrated 200 — decision B's owned origin behind one constant. Subjects became urn:yidam:<corpus>/<kind>/<path>, derived by re-scheming render_reference's output rather than assembled a second time, and the dataset became urn:yidam:<corpus> — an authority with no path, because a corpus is what references are resolved against and not a thing inside one.

<corpus> here is the genesis commit hash, not the declared package name, and the first implementation had it the other way round. Zero of the sixteen corpora with tracked nodes declare a package name — none has a .yidam/tonpa.toml at all — so a subject built on it fell back to a constant for every corpus that exists, leaving §2's collision exactly where it was while appearing to fix it. The genesis hash is also the only corpus identity that cannot be renamed, which a published subject needs and a nickname cannot promise. §4.5 is unchanged: the declared name is right for an identifier a person reads or types, and these are different jobs — the same split §4.2 makes between an identifier and a locator, one level down.

Running the exporter over two real corpora found two more things no fixture had:

  • 55 subjects were malformed, 37 of 185 in one corpus and 18 of 810 in the other, all one shape: ../../catalog/<file>.md link targets minted as urn:yidam:<hash>/node/../../catalog/<file>.md — relative segments inside an identifier, typed as a node, for a thing that is a catalog entry. The catalog kind in §4.1 is what they are, so the fix was to use the grammar rather than to escape around it. Nothing else escapes the corpus directory in either corpus, so this is complete and not a first case. A prefix-checking guard cannot see this; the guard now parses each subject back and applies reference_conforms.
  • An unidentifiable corpus is refused, not given a shared name. Any constant is the same string for every corpus that reaches that branch, so two of them merged into one store would conflate their nodes. The constant arrived anyway, from the other direction (#792): git resolves upward, so a corpus that is a directory inside a repository was handed the enclosing repository's genesis — and all four corpora under examples/ minted urn:yidam:094509a128f4, one owl:Ontology subject asserting four different labels. A host's identity is a constant shared by every corpus nested in it, reached by satisfying the check rather than by failing it. genesis_hash now answers only for a corpus that is its own repository. The branch is reachable — a worktree copied out of its parent, a shallow clone without the root commit, a .yiz extracted to a plain directory — and at the time the bundle manifest could not supply it, because it recorded genesis as an ISO date. The addressing plan's decision C assumed a digest was already there. #781 put one there: manifest.yml now carries genesis_hash, additively, with absence meaning unidentified and never a placeholder — see §4.5.

Two things this deliberately did not do. §4.2's locator branch is not implemented: it needs a corpus to declare a base, public_base is RFC-0027's and unshipped, and a branch nothing can reach is the surface-with-no-consumer shape. And the namespace is owned but does not yet serve a document — the docs site is versioned, so a page describing these terms reaches /yidam/main/… on merge and this path at the next cli/v* tag. The guard asserts ownership, not resolution, because a check keyed on an artifact that does not exist yet goes red the day it lands.

3 — Only a struct can say which corpus, at which revision

qualified_id renders pkg::class/name and is the only string form carrying a corpus. ExternalCitation carries package, node, commit and tag — the only identifier in the system that can name a foreign node at a known revision, and it is four fields rather than a string, so it cannot appear in a resource URI, an RDF subject, a query result, or a rendered citation. Meanwhile resolve_link_target resolves an on-disk edge from a relative path, which is a fifth convention, and unrelated to any of the above.

4 — Eleven forms, and the count is the argument

FormBuilt byCorpus?Revision?
class/namecorpus_nodes——
pkg::class/namequalified_idyes—
.yidam/corpus/class/name.ymltolerated by find_node——
../other-class/thing.ymlresolve_link_target——
yidam://corpus/class/nameresources.rs:56——
the same string as an RDF subjectinstance_iri——
file:///…/class/name.ymlpath_to_urin/a—
/node/class/namenodeHref——
a GraphML node idexport_graphml.rs——
{package, node, commit, tag}ExternalCitationyesyes
<public-base>/class/nameRFC-0027 §5, unshippedyes—

Nine of the eleven can say neither. Three surfaces also disagreed about encoding the same id until #775 wrote the character set down, which is the precondition this RFC needed — though what that check makes invariant is narrower than this RFC first assumed, and §4.1's amendment measures by how much.

Proposal

4.1 — The grammar

identifier   yidam://<corpus>/<kind>/<path>[@<rev>][#<property-path>]
locator      https://<base>/<kind>/<path>
relative     <kind>/<path>  |  <path>          resolved against the containing corpus
kind         node | crate | catalog | skill | decision | issue

The corpus moves into the authority and the kind into the path, which is the minimal change that creates the slot §1 lacks. <path> is <class>/<name> for node and a single segment for the others. Every segment in a conforming corpus is a slug — the rule name_not_a_slug reports against, through its predicate is_slug — so no percent-encoding is required anywhere in this grammar, which is why there is one string form and not one per encoder.

Amended 2026-09-09 (#777): a conforming corpus, not every corpus. This RFC was written on the claim that #775 made the character set an invariant. Measured with the shipped binary against the sixteen corpora that have tracked nodes, fourteen conform and two do not: yidam-proto-001d reports 6 findings and yidam-proto-002c 16, with yidam lint exiting 1 in both. Both are the youngest corpora measured, and both took class names from their domain's own vocabulary in its own case — NonConformance, DischargePoint. Kebab-case is what corpora converge on, not what they start with, and yidam lint --bless is the supported way to adopt a check over names you already wrote. So a non-conforming corpus is a state the system offers, not merely one it fails to prevent.

The grammar is unchanged: a conforming id still needs no escaping, which is the property §4.6's single parser rests on. What changes is that the parser may not assume it.

Amended 2026-09-10 (#783): kind is six, and the sixth arrived by measurement. Across the five corpora that write evidence-tag details, 496 references sit inside brackets where nothing can read them — and 252 of them are issue references, [verified — #362], the single largest shape in the population. The kind list was argued as closed and that argument was made without this count. The corpus writing them had already paid for their absence: its own .yidam/corpus/README.md warns to quote any properties: value containing an issue reference, because YAML reads an unquoted # as a comment.

issue/362 relative, yidam://<corpus>/issue/362 absolute, one path segment. It takes the arity rule with it at no cost: a corpus with a class named issue still renders node/issue/reopened and still round-trips, by the same mechanism skill already used.

What the measurement did not require was a seventh. 204 of the 496 are repo-relative paths, and splitting them by top-level directory showed they are the kinds already here written differently — 158 crates/…, 25 ../../catalog/…, 13 ../<class>/<name>.yml, 7 decisions/…, one file under no crate, and three formulas that are not references at all. So the RFC's own open question 3 — whether crate wants a name that is not one language's — stays open without blocking anything. §4.6 carries the consequence.

Which relative form applies is decided by arity, not by preference. <kind>/<path> and a bare <path> share a shape, and a corpus may legitimately declare a class named node — nothing reserves the five words. So <path>'s segment count decides: reading the leading word as a kind must leave exactly that kind's arity (two segments for node, one for the others), or the word was a class name and the whole string is the path. node/concept/foo is the node concept/foo; node/foo is the node foo in a class called node. Where both readings are valid — skill/foo, in a corpus with a class named skill — the kind wins, because the grammar puts a kind in that position, and §4.6's renderer emits the explicit node/skill/foo for the other reading so that parse and render stay inverses. Nothing is reserved and nothing collides.

RFC-0005's normative scheme section is amended: three of the five URIs it froze map into the new shape as aliases, so a client written against 0.18.0 keeps working. The other two do not map at all (#779): yidam://corpus/<class> names a collection and yidam://graph/summary a computed report, and the grammar addresses things with identity. Both parse as not a reference, which is correct for a reference parser and left a decision for P4 — whether the resource surface is a superset of this grammar or a different vocabulary that overlaps it. §4.9 records the answer: neither.

4.2 — Two renderings, because they have two jobs

RFC-0027 §5 established that a field whose purpose is a reader can follow this cannot hold a yidam:// URI. That argument does not generalise into identity must be a URL — it generalises into stop asking one string to do both. An identifier must survive a .yiz tarball, a private corpus and an offline clone, none of which have a host. A locator must be followable. So:

  • The identifier is authoritative for equality, traversal, tool arguments and the lock file.
  • The locator is derived, per-corpus, from a declared base, and is what appears anywhere a stranger reads the output — a rendered citation, an RDF subject, a search result's url.
  • An RDF subject uses the locator where a base is declared and a urn:yidam: form where none is. It never uses a yidam:// IRI, which is §2's defect.

4.3 — A revision is a pin, not identity

x and x@abc denote the same node in two states, and the resolver reports which it returned. ExternalCitation already settled this by holding node and commit as two fields; following the split means no existing identifier changes meaning, where folding the revision into identity would silently make every id in every corpus name something else.

4.4 — A fragment addresses something that has a name, and never a claim

RFC-0008 measured this rather than assumed it: across 29 resolutions and 70 tips, 22 claims entered corpora in resolution commits and 0 matched byte-identically at any participating tip, because a sentence search that ends at \n extracts one claim as two different strings in two hard-wrapped nodes. Identity by surface form is identity by line wrapping.

So the fragment names something that has a name, and the grammar refuses a fragment naming a claim. The consequence for the request that prompted this RFC: which nodes state this figure? is answerable the moment the figure is the addressed thing, and unanswerable as long as the claim wrapped around it is. Address the figure.

Amended 2026-09-10 (#783): what has a name depends on the kind. This section said a declared property path, full stop, and that is right for a node. It is wrong for a crate: 32 details in the measured population name a Rust item — `dispersion::ohio_panel::equalization_by_year` — and 158 more name a file inside a crate, and neither is a dotted slug path. With crate holding a single path segment (§4.1's arity rule, which the alternative of a multi-segment crate path would have broken), the fragment is the only slot left for them.

So the rule is per kind. For a crate, the fragment is a code item or a file: segments over [A-Za-z0-9_.-], joined by / or ::. Uppercase and . are admitted deliberately — a type is CamelCase and a file has an extension, and those are a foreign toolchain's naming rules, not this project's to impose. For every other kind it is the dotted property path this section already specified.

The refusal is untouched, and its reason is why the widening is safe. What §4.4 refuses is a fragment naming a claim, and the argument is RFC-0008's measurement: 0 of 22 claims matched byte-identically, because identity by surface form is identity by line wrapping. A Rust item path has an identity the compiler enforces and a file path one the filesystem does. The measurement that rules out a claim says nothing against either, so widening here does not weaken the refusal — it stops the refusal from catching two things it was never about.

4.5 — The corpus name, and a collision nobody can currently see

The authority is the declared package name from PackageMeta — the value every surface already prints. It is a nickname chosen by whichever repository declared the dependency, so it is unique within one .yidam/tonpa/ and not globally. Rather than invent a global identifier and make every printed id unreadable, this RFC makes a collision detectable: a consumer holding two corpora that claim one name says so, using the genesis digest each manifest carries. This is #610's question one layer down and the answers must not contradict.

The digest was not there when this was written (#781), and finding out where the collision is actually reachable narrowed what "detectable" means. It is not two entries in one .yidam/tonpa/, which cannot exist — the directory name is the declared name. It is a path dependency and an unpacked bundle claiming one name, which resolved already resolves in favour of the checkout and does so silently. Silence is right in the common case, where the two are one corpus in two forms: someone fetched a dependency and then pointed at a checkout of it to edit. It is wrong when they are different corpora, because then the reader is reading one while tonpa.lock pins the other, and every answer that corpus gives is the wrong corpus's.

So the digest is what makes the distinction decidable rather than the collision detectable — same hash, one corpus; different hash, two. doctor's corpora check reports the second and stays quiet on the first. It also stays quiet when either identity is missing, which is the rule the rest of this RFC applies to unidentifiable corpora: unknown is not different. Guessing would either invent a conflict on every bundle built before the field or hide a real one.

4.6 — One parser

yidam_core::uri parses and renders the grammar and becomes the only place an identifier is built or split. It retires find_node's three tolerated spellings, qualified_id, instance_iri, resources.rs:56's prefix chain and nodeHref's route builder. It lands on the parity surface, so Rust, TypeScript and Python must agree — three implementations and one shared case set, not one implementation.

It is total, and it reports conformance rather than requiring it (amended, #777). §4.1's measurement found two corpora whose segments are not slugs, reachable through the --bless the check itself offers. Three ways to handle that, and only one of them ends the problem this RFC is about:

  • Refuse a non-slug segment. Then 6 of yidam-proto-002c's 10 nodes cannot be named at all, and every consumer grows a fallback path for the corpus in front of it — the per-surface improvisation §1 diagnoses, reintroduced by the fix for it.
  • Escape it. One string form becomes one per encoder, which is the state §4.1's no-escaping property exists to leave.
  • Parse structurally, and answer whether the result conforms. The parser splits on /, @ and # for any input, and a separate predicate says whether every segment is a slug. A caller that must emit a URI can then act on the answer.

The third, because the repository already does exactly this one layer out: export_rdf.rs:317 tests a foreign alignment IRI for a scheme it can dereference and demotes it to a literal when it fails. §2's complaint is that it applies that test to other people's IRIs and not to its own. Reporting conformance on our own identifiers is that same test, turned inward — which makes this amendment continuous with the problem statement rather than a concession against it.

Enforcement stays where it already is: name-not-a-slug is the check, at Error, and a corpus that blessed its findings has recorded a state rather than acquired a licence. The parser's job is to be honest about what it was handed.

4.7 — Where a reference is written down

A grammar for a reference is half of what the request behind this RFC needed. The other half is a place to put one. A derived corpus folded 168 crate paths into evidence-tag details because the tag bracket was the only place a reference could be written at all — so a grammar that stays unwritten anywhere is a grammar that changes nothing.

So a node gains references:, a list of references in this grammar, as strings:

class: coupling
label: First and last mile
references:
  - issue/362
  - crate/dispersion#ohio_panel::equalization_by_year
  - catalog/lsc-greenbook

Three things about that shape, each of which had an alternative:

  • Strings, not structs. parse_reference is the reader. A struct here would be a second encoding of the identifier this grammar already spells, which is the defect §1 diagnoses, reproduced inside its own fix. cites: keeps its four fields because it means something narrower: a node in another corpus at a known revision.
  • Named, not left to the instance parser's passthrough. A references: key already survived into extra, so a corpus could write one today and nothing would read it. That is precisely how [unentered] happened — a corpus coined a mark, the renderer assigned it a meaning nobody chose, and the prose ended up denying what the badge asserted. A field that is named is one a check reads.
  • On the node, not on a claim. §4.4's measurement makes a per-claim attachment impossible, and pretending otherwise would put a reference on an anchor that moves when a line rewraps.

reference-not-in-the-grammar is the reader, at Warn, and it names which clause of reference_conforms an entry missed rather than reporting "not a reference" — three causes with three different fixes.

What this section does not decide is what a detail means, whether a tag carrying one is a claim, or where a scope qualifier goes. Those are #710 / RFC-0031's, and the measurement that split them is in #783. This RFC is normative for the reference and its home, and deliberately silent on the tag.

4.8 — Getting the references that already exist into it

Added 2026-09-09 (#783).

§4.7 gives a reference a home; it does not put anything in it. Across the seven corpora that write evidence-tag details there are enough of them that nobody was going to move them by hand, so yidam migrate references does, as a fifth subcommand of the migration surface — the one operation there that migrates data rather than the ontology over it.

Measured across those seven corpora, 2026-09-09:

what happens
the detail is the referencethe entry is written and the tag collapses to its bare standing
the reference sits inside a sentencethe entry is written and the sentence is left exactly as written
the detail names nothing addressablenothing is written; it is counted, not listed

The two corpora that write most of them yield 212 references across 94 nodes and 343 across 147.

Three rules decide it, and each replaces a judgement:

  • Nothing but an issue number is written unless the thing it names exists on disk. That is the whole defence against guessing, and it is what lets the resolver read shapes it would otherwise have to refuse: Auglaize/Mercer, land-use/transport and 6a/6b have a path's shape and are prose using a slash for or. They resolve to no file, so they are prose, and no rule about English had to be written to decide it.
  • Nothing is written that reference_conforms rejects. A class named NonConformance is a name two of the sixteen corpora write and §4.1's amendment admits is real (#777). Writing it here would redden reference-not-in-the-grammar on the next lint of the corpus just migrated.
  • The prose is never rewritten to make a reference fit. A detail whose reference is a grammatical part of a sentence gets the entry and keeps the sentence, which writes the reference twice. That is the cost; the alternative is a migration that mangles prose. checks.rs had already recorded the sharp version of this — a narrowing detail ([verified as proposed]) must never become a bare [verified], because that asserts the proposal was adopted.

The check on it is not a test: applying it to both corpora leaves yidam lint reporting exactly what it reported before, less one claim-tag-malformed finding per collapsed tag — 535 → 399 and 534 → 459, against 136 and 75 collapses.

4.9 — The resource surface, decided

Added 2026-09-10.

§4.1 left P4 a choice between two ways for yidam:// to mean one thing. The answer is neither, and the reason is a measurement taken before building either.

The plan had this step add a corpus slot to the resource namespace, so a client could fetch a node from a named dependency, and spend the MCP contract's minor bump doing it. Measured first: ReadMcpResourceTool was invoked 0 times across 1,638 local sessions, for any server, and 0 of the 16 derived corpora write cites: or vendor a dependency. It would have been a slot for an address nobody writes, reachable by a mechanism nobody calls. So the slot is not built, and serve/resources.rs refuses a URI naming any corpus in one arm that says why — the decision is in the code rather than in its absence.

What is unified is the reading. The resource surface answered what does this URI name? with its own chain of strip_prefix calls while [yidam_core::uri] answered it for every other caller — two readers of one scheme, which is the defect §1 is about, reproduced inside its own fix. It now parses through parse_reference and adds only what the grammar deliberately cannot name: a Collection for yidam://corpus/<class> and a Report for yidam://graph/summary, named where they are served rather than added to Kind. The grammar stays the closed set of things with identity, which is #779's own argument for why those two do not belong in it.

Arity and kind decide there, not reference_conforms. Conformance answers may this be written into a URI, which is a different question from does this corpus contain it: gating the server on it would stop serving the nodes of the two corpora §4.1's amendment exists to admit (#777). The grammar parses the string; the corpus decides what exists.

The spelling stays frozen. resources/list still emits yidam://corpus/<class>/<name>, which is not what render_reference produces for that node. RFC-0005 froze it and this step spends no contract bump, so the freeze wins and a test holds the two halves together: every URI the listing offers is one the reader resolves. Nothing asserted that before — the prefix chain was written to match what the listing emitted, so a divergence would have reached a client as a 404 rather than a red build.

What this does not touch

  • The vault and catalog schemes. s3://, file://, and the catalog's four location kinds are locators for bytes. They work, they are argued, and they are not identity.
  • The on-disk format. links: keeps relative paths and cites: keeps its four fields. §4.3 adds a rendering of cites:, not a replacement for it.
  • The scope half of the evidence-tag request. What is asserted, and one sentence carrying two standings, are RFC-0031's and #710's. No identifier helps there, and the measurement that settled the split put ~11% of details on that side.
  • Making more findings dated. #774 is a separate gap.
  • The [verified · checked] axis. Parked deliberately; it bumps the frozen claim_tags vocabulary and should be costed on its own evidence.

Migration & compatibility

Nothing in a corpus changes. The identifier is derived from the same path segments the current forms are derived from, so every existing node has the same identity before and after; what changes is that the string naming it is produced in one place.

The MCP contract takes a minor bump in all three copies it is written down in (mcp/tools.json, mcp/VERSION, and the README example). Because RFC-0005's five URIs stay valid as aliases, a client that never adopts the new form keeps working, and one that does gains the ability to address a dependency node — which no client can do today.

Sequencing: this RFC's §4.1–4.3 and §4.6 are P1 of the addressing plan and need no other work. §4.2's locator half depends on a corpus declaring a base, which is RFC-0027's public_base generalised; §2's namespace fix is independent and can land beside it.

Alternatives considered

  • Restructure yidam:// and stop there. The smallest diff, and it leaves §2 unfixed: RDF subjects stay in an unregistered scheme and corpora still collide. Rejected because the RDF export is a shipped surface, not a future one.
  • Adopt urn:yidam: as the primary form. Formally correct — a node id is a name, not a location — and legitimate as an RDF subject with no domain. Rejected as the primary because it renames a scheme frozen in a contract with three copies, is unfamiliar to every client author, and still needs a locator for followable URLs. It survives in §4.2 as the RDF fallback, which is the one job a URN does better than either alternative.
  • HTTPS-first: identity is a URL. Dereferenceable and RDF-clean by construction. Rejected because it makes identity contingent on hosting: a corpus in a tarball, or private, could not name its own nodes. RFC-0027 made --public-base a hard refusal for this reason.
  • Fold the revision into identity. Cleaner to reason about formally, and it silently changes what every id in every existing corpus refers to, with no migration that can fix prose already written.
  • Let the fragment name a claim. What the downstream request asked for, and what RFC-0008 measured to be impossible by surface form. Declined in §4.4 with the measurement, so it is not re-proposed.

Open questions

  • Does the alias mapping need to be normative, or is it a compatibility note? If a tools-only server must reproduce it exactly, it belongs in the contract; if it is only the Rust server's transitional courtesy, it does not. Sharpened by #779: the question only arises for the three URIs that have a mapping, because the other two turn out to address things the grammar does not name.
  • What does the locator do for a dependency node whose corpus declares no base? RFC-0027 §5 chose to omit and count the omission. That is right for a search result and possibly wrong for an RDF subject, where omitting the node loses an edge rather than a row.
  • Is crate the right kind name? It names a Rust crate today and the compute layer is crates/ and packages/. A kind that means the code beside this corpus may want a name that is not one language's.