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
urla reader follows cannot be ayidam://URI, and whosepublic_basethis 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)
- RFC-0005 (which declared the
- 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:andcites: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 becameurn:yidam:<corpus>/<kind>/<path>, derived by re-schemingrender_reference's output rather than assembled a second time, and the dataset becameurn: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.tomlat 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>.mdlink targets minted asurn:yidam:<hash>/node/../../catalog/<file>.md— relative segments inside an identifier, typed as a node, for a thing that is a catalog entry. Thecatalogkind 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 appliesreference_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/mintedurn:yidam:094509a128f4, oneowl:Ontologysubject 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_hashnow 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.yizextracted to a plain directory — and at the time the bundle manifest could not supply it, because it recordedgenesisas an ISO date. The addressing plan's decision C assumed a digest was already there. #781 put one there:manifest.ymlnow carriesgenesis_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_baseis 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 nextcli/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
| Form | Built by | Corpus? | Revision? |
|---|---|---|---|
class/name | corpus_nodes | — | — |
pkg::class/name | qualified_id | yes | — |
.yidam/corpus/class/name.yml | tolerated by find_node | — | — |
../other-class/thing.yml | resolve_link_target | — | — |
yidam://corpus/class/name | resources.rs:56 | — | — |
| the same string as an RDF subject | instance_iri | — | — |
file:///…/class/name.yml | path_to_uri | n/a | — |
/node/class/name | nodeHref | — | — |
a GraphML node id | export_graphml.rs | — | — |
{package, node, commit, tag} | ExternalCitation | yes | yes |
<public-base>/class/name | RFC-0027 §5, unshipped | yes | — |
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-001dreports 6 findings andyidam-proto-002c16, withyidam lintexiting 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, andyidam lint --blessis 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):
kindis 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.mdwarns to quote anyproperties:value containing an issue reference, because YAML reads an unquoted#as a comment.
issue/362relative,yidam://<corpus>/issue/362absolute, one path segment. It takes the arity rule with it at no cost: a corpus with a class namedissuestill rendersnode/issue/reopenedand still round-trips, by the same mechanismskillalready 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, 7decisions/…, one file under no crate, and three formulas that are not references at all. So the RFC's own open question 3 — whethercratewants 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 ayidam://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. Withcrateholding a single path segment (§4.1's arity rule, which the alternative of a multi-segmentcratepath 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 isCamelCaseand 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_referenceis 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 intoextra, 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 reference | the entry is written and the tag collapses to its bare standing |
| the reference sits inside a sentence | the entry is written and the sentence is left exactly as written |
| the detail names nothing addressable | nothing 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/transportand6a/6bhave 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_conformsrejects. A class namedNonConformanceis a name two of the sixteen corpora write and §4.1's amendment admits is real (#777). Writing it here would reddenreference-not-in-the-grammaron 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.rshad 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 andcites:keeps its four fields. §4.3 adds a rendering ofcites:, 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 frozenclaim_tagsvocabulary 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-basea 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
cratethe right kind name? It names a Rust crate today and the compute layer iscrates/andpackages/. A kind that means the code beside this corpus may want a name that is not one language's.