@pubid/pubid 0.1.5 → 0.1.6

package/README.md

@@ -87,12 +87,28 @@ The conformance gate enforces corpus mode over the whole testsuite on
 every CI run: 42/42 flavors, canonical hash, human form, URN, alias
 normalization, negative rejection and deserialize idempotency.
 
-Grammar-backed parsing (novel identifiers beyond the published corpus)
-lands wave by wave and takes over per flavor — the same gate then
-enforces parity, so a wave can never regress below the floor corpus
-mode set (waves: core model → parser engine → builder → normalizer →
-renderer → urn → iso → iec → …). **No wave has shipped yet**; until one
-does, every flavor is corpus-only.
+## Grammar mode: open-universe runtime parsing
+
+All 42 flavors are grammar-backed and ship the wave plan end to end
+(core model → parser engine → builder → normalizer → renderer → urn →
+per-flavor grammars). Grammar implementations parse real-world
+identifiers far beyond the published corpus — novel spellings, unseen
+numbers, live catalogues — and the conformance gate still enforces
+parity with the corpus floor on every run, so a grammar can never
+regress below what corpus mode set:
+
+```ts
+import { grammarImplementation } from "@pubid/pubid";
+
+const oiml = grammarImplementation("oiml")!;
+oiml.parse("OIML R 60-1:2021");            // any published identifier
+oiml.parse(oiml.parse("OIML R 117-1").toUrn()!); // URNs ingest back
+```
+
+`grammarImplementation` is exported from the package root. URN ingestion
+ships per flavor where the Ruby reference implements a URN parser
+(oiml today; the remaining flavors throw a clear "not yet supported"
+error naming this issue until their ports land).
 
 ## Development
 

package/dist/conformance/implementation.d.ts

@@ -7,6 +7,9 @@
 export interface FlavorImplementation {
     /** Parse a canonical human form; must throw on a bad input. */
     parse(input: string): Identifier;
+    /** Inverse of toUrn for flavors whose reference implements a URN
+     *  parser; when absent, "urn:" inputs throw a not-supported error. */
+    parseUrn?(urn: string): Identifier;
 }
 export interface Identifier {
     /** The canonical serialized form - compared byte-exactly against the corpus identifier record. */

package/dist/flavors/bipm/index.js

@@ -422,6 +422,45 @@ class BipmBuilder {
 export function bipmGrammarImplementation() {
     const builder = new BipmBuilder();
     return {
+        // Inverse of BipmUrnGenerator (lib/pubid/bipm/urn_parser.rb): rebuild
+        // the identifier DIRECTLY from the URN fields — the printed forms carry
+        // surface detail (meeting ordinals, French wording) the URN omits.
+        parseUrn(urn) {
+            const body = urn.replace(/^urn:bipm:/, "");
+            // Keep trailing empty segments (gem splits with -1).
+            const parts = body.split(":");
+            const presence = (v) => v === undefined || v === "" ? undefined : v;
+            if (parts[0] === "metrologia") {
+                return new BipmMetrologiaArticle({
+                    number: presence(parts[1]),
+                    issue: parts[2],
+                    article: parts[3],
+                });
+            }
+            if (parts[0] === "si-brochure") {
+                return new BipmSiBrochure({
+                    number: presence(parts[2]),
+                    language: (parts[1] ?? "").toUpperCase(),
+                    edition: parts[2],
+                    version: parts[3],
+                    years: parts[4],
+                });
+            }
+            const group = (parts[0] ?? "").toUpperCase();
+            if (parts[1] === "meeting") {
+                return new BipmMeeting({
+                    group,
+                    number: parts[2] ?? "",
+                    year: parts[3] ? Number(parts[3]) : undefined,
+                });
+            }
+            return new BipmCommitteeDocument({
+                group,
+                type_code: presence(parts[1])?.toUpperCase(),
+                number: presence(parts[2]),
+                year: parts[3] ? Number(parts[3]) : undefined,
+            });
+        },
         parse(input) {
             const normalized = UPDATE_CODES[input] ?? input;
             const tree = parseGrammar(bipmGrammar, normalized);

package/dist/flavors/iec/index.js

@@ -1,4 +1,5 @@
 import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { TYPED_STAGES } from "./model.js";
 import { Language, PubidDate } from "../../model/component.js";
 import { iecGrammar, preprocessIec } from "./grammar.js";
 import { locateStage, IEC_CLASSES, } from "./model.js";
@@ -493,6 +494,27 @@ for (const klass of [
 export function iecGrammarImplementation() {
     const builder = new IecBuilder();
     return {
+        // Inverse of the IEC UrnGenerator (lib/pubid/iec/urn_parser.rb):
+        // reassemble the positional URN fields into a text code, parse it, then
+        // attach languages and the all-parts wrap.
+        parseUrn(urn) {
+            const parsed = urnToCode(urn);
+            if (!parsed)
+                throw new Error(`Invalid IEC URN: ${urn}`);
+            const [code, lang, allParts] = parsed;
+            // The reference parses the unprefixed rebuild and its grammar
+            // defaults the IEC publisher; the ts grammar needs it explicit.
+            const id = this.parse(code);
+            if (lang && lang !== "" && "languages" in id) {
+                id.languages = lang
+                    .split("-")
+                    .map((c) => new Language({ code: c }));
+            }
+            if (allParts) {
+                id.all_parts = true;
+            }
+            return id;
+        },
         parse(input) {
             let tree;
             try {
@@ -505,3 +527,61 @@ export function iecGrammarImplementation() {
         },
     };
 }
+// Port of Relaton::Iec.urn_to_code + the slot helpers
+// (lib/pubid/iec/urn_parser.rb): reassemble the positional URN fields into
+// a text code. Returns [code, language, allParts].
+function urnToCode(urn) {
+    const fields = urn.toUpperCase().split(":");
+    if (fields.length < 5)
+        return undefined;
+    const [head, num, date, type, deliv, lang] = fields.slice(3, 9);
+    let allParts = false;
+    let code = head.replaceAll("-", "/");
+    const typeCode = typeSlotToCode(type);
+    if (typeCode !== "")
+        code += ` ${typeCode}`;
+    code += ` ${num}`;
+    if (date !== undefined && date !== "")
+        code += `:${date}`;
+    code += adjunctToCode(fields.slice(9));
+    if ((deliv ?? "").toLowerCase() === "ser") {
+        allParts = true;
+    }
+    else if (deliv !== undefined) {
+        const edition = editionSlotToCode(deliv);
+        if (edition)
+            code += ` ${edition}`;
+        else if (deliv !== "")
+            code += ` ${deliv}`;
+    }
+    return [code, lang?.toLowerCase(), allParts];
+}
+// The type slot holds a legacy type token ("TS"), a stage
+// ("STAGE-10.20"), or both ("TS-STAGE-50.00"); a stage is written back as
+// the abbreviation resolved from the typed-stage registry.
+function typeSlotToCode(type) {
+    if (type === undefined || type === "")
+        return "";
+    const match = type.match(/^([A-Z]+-)?STAGE-([\d.]+)$/);
+    if (!match)
+        return type;
+    const stageType = (match[1] ?? "IS-").replace("-", "").toLowerCase();
+    const stage = TYPED_STAGES.find((t) => t.typeCode === stageType && (t.harmonized ?? "") === match[2]);
+    return stage ? stage.abbr : "";
+}
+// "ED-7" in the deliverable slot is an edition, not a deliverable code.
+function editionSlotToCode(deliv) {
+    const match = deliv?.match(/^ED-(.+)$/);
+    return match ? `ED${match[1]}` : undefined;
+}
+// Adjuncts are (relation, type, number, date) quartets; a "PLUS" relation
+// yields "+", otherwise "/".
+function adjunctToCode(fields) {
+    if (!fields.length)
+        return "";
+    const [rel = "", type = "", num = "", date = ""] = fields.slice(0, 4);
+    let code = (rel === "" ? "/" : "+") + type + num;
+    if (date !== "")
+        code += `:${date}`;
+    return code + adjunctToCode(fields.slice(4));
+}

package/dist/flavors/index.js

@@ -1,3 +1,4 @@
+import { lookupUrnParser, parseUrnFor } from "../urn/parsers.js";
 import { oimlGrammarImplementation } from "./oiml/implementation.js";
 import { xsfGrammarImplementation } from "./xsf/index.js";
 import { doiGrammarImplementation } from "./doi/index.js";
@@ -47,6 +48,32 @@ import { ialaGrammarImplementation } from "./iala/index.js";
  * flavor NOT listed falls back to corpus mode.
  */
 export function grammarImplementation(flavor) {
+    const impl = grammarImplementationSwitch(flavor);
+    if (impl === undefined)
+        return undefined;
+    // "urn:" inputs route to the flavor's URN parser where the reference
+    // implements one (impl.parseUrn or the registry in src/urn/parsers.ts
+    // mirroring lib/pubid/<flavor>/urn_parser.rb); flavors without one whose
+    // own grammar accepts URN spellings keep parsing them natively
+    // (pubid/pubid-ts#1).
+    const urnDef = lookupUrnParser(flavor);
+    if (impl.parseUrn === undefined && urnDef === undefined)
+        return impl;
+    return {
+        parse(input) {
+            if (/^urn:/i.test(input)) {
+                if (impl.parseUrn)
+                    return impl.parseUrn(input);
+                return parseUrnFor(urnDef, input, impl.parse);
+            }
+            return impl.parse(input);
+        },
+        ...(impl.parseUrn
+            ? { parseUrn: impl.parseUrn }
+            : { parseUrn: (urn) => parseUrnFor(urnDef, urn, impl.parse) }),
+    };
+}
+function grammarImplementationSwitch(flavor) {
     switch (flavor) {
         case "oiml":
             return oimlGrammarImplementation();

package/dist/flavors/jcgm/index.js

@@ -288,6 +288,27 @@ class JcgmBuilder extends BaseBuilder {
 export function jcgmGrammarImplementation() {
     const builder = new JcgmBuilder();
     return {
+        // Inverse of JcgmUrnGenerator (lib/pubid/jcgm/urn_parser.rb): rebuild
+        // identifiers DIRECTLY from the URN segments — re-parsing through the
+        // grammar flattened segments and lost languages/supplements.
+        parseUrn(urn) {
+            const parts = urn.replace(/^urn:jcgm:/, "").split(":");
+            if (parts[0] === "meeting") {
+                const number = toMeetingNumber(parts[1]);
+                const date = urnDate(parts[2]);
+                return new (KIND_CLASSES.meeting)({ number, date });
+            }
+            const markerAt = parts.findIndex((seg) => seg === "corrigendum" || seg === "amendment");
+            if (markerAt === -1) {
+                return buildUrnDocument(parts);
+            }
+            const kind = (parts[markerAt] === "amendment" ? "amendment" : "corrigendum");
+            const base = buildUrnDocument(parts.slice(0, markerAt));
+            const tail = parts.slice(markerAt + 1);
+            const number = tail[0] === undefined || tail[0] === "" ? undefined : tail[0];
+            const date = urnDate(tail[1]);
+            return new (KIND_CLASSES[kind])({ base, number, date });
+        },
         parse(input) {
             const tree = parseGrammar(jcgmGrammar, input);
             if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
@@ -297,4 +318,44 @@ export function jcgmGrammarImplementation() {
         },
     };
 }
+// lib/pubid/jcgm/urn_parser.rb build_document: Guide vs GumGuide by the
+// "gum." number prefix; the year and language segments are matched by
+// pattern, not position.
+function buildUrnDocument(parts) {
+    const number = parts[0];
+    if (number === undefined || number === "") {
+        throw new Error("JCGM URN has no document number");
+    }
+    const gum = number.startsWith("gum.");
+    const rest = parts.slice(1);
+    const year = rest.find((seg) => /^(19|20)\d{2}$/.test(seg));
+    const langSegment = rest.find((seg) => /^[a-z]{2}(,[a-z]{2})*$/.test(seg));
+    const langLetters = {
+        ru: "R", fr: "F", en: "E", ar: "A", es: "S", de: "D",
+    };
+    const languages = langSegment
+        ? langSegment.split(",").map((code) => new Language({ code, originalCode: langLetters[code] ?? code }))
+        : [];
+    const cls = gum ? KIND_CLASSES["gum-guide"] : KIND_CLASSES.guide;
+    const cleanNumber = gum ? number.slice("gum.".length) : number;
+    return new cls({
+        number: cleanNumber,
+        date: year ? new PubidDate({ year }) : undefined,
+        languages,
+    });
+}
+// nil for an absent year; a component for a well-formed 19xx/20xx year;
+// anything else rejects (no re-parse validates it any more).
+function urnDate(segment) {
+    if (segment === undefined || segment === "")
+        return undefined;
+    if (!/^(19|20)\d{2}$/.test(segment)) {
+        throw new Error(`Invalid year in JCGM URN: ${JSON.stringify(segment)}`);
+    }
+    return new PubidDate({ year: segment });
+}
+// "011" reads back as "11" (Identifiers::Meeting.ordinal normalization).
+function toMeetingNumber(segment) {
+    return String(Number(segment));
+}
 export { isObj };

package/dist/flavors/nist/grammar.js

@@ -271,12 +271,19 @@ function buildRules() {
         .as("series")
         .then(space.or(dot))
         .as("circ_series")
-        .then(str("supp")
+        .then(
+    // Bare supplement marker to the whole series, no base number
+    // ("NBS.CIRC.sup" — testsuite#5 C4).
+    ((str("supp").or(str("sup"))).then(monthAbbrev().then(digits).as("supplement_month_year").or(digits.as("supp_number").then(slash, digits.as("supp_year")).as("supplement_slash_year"), str("").as("supplement_empty")).maybe())).or(
+    // Date-range supplement (no base document).
+    str("supp")
         .then(monthAbbrev().as("supp_month_start"), digits.as("supp_year_start"), dash, monthAbbrev().as("supp_month_end"), digits.as("supp_year_end"))
         .as("supplement_date_range")
         .or((str("supp").or(str("sup")))
         .then(match("[0-9]").repeat(4, 4).as("supp_year_start"), dash, match("[0-9]").repeat(4, 4).as("supp_year_end"))
-        .as("supplement_date_range"), (digits.as("base_number").then(str("e"), digits.as("edition_number")).or(digits
+        .as("supplement_date_range"))).or(
+    // Base identifier + supplement.
+    (digits.as("base_number").then(str("e"), digits.as("edition_number")).or(digits
         .as("base_number")
         .then(lowerLetter.as("revision_letter"), digits.as("revision_number")), digits.as("base_number").then(upperLetter.as("letter_suffix")), digits.as("simple_number")))
         .as("base_portion")

package/dist/flavors/nist/index.js

@@ -803,6 +803,7 @@ class NistBuilder {
             h["supplement_month_year"] !== undefined ||
             h["supplement_year"] !== undefined ||
             h["supplement"] !== undefined ||
+            h["supplement_empty"] !== undefined ||
             h["base_portion"] !== undefined) {
             return this.buildCircularSupplement(h);
         }
@@ -1094,9 +1095,12 @@ class NistBuilder {
             return this.buildCircularSupplementWrapper(h);
         }
         const seriesValue = isObj(h["circ_series"]) ? s(h["circ_series"]["series"]) : s(h["series"]);
+        // The dotted series literal ("NBS.CIRC") names its publisher in the
+        // first token; the builder default would render "NIST" instead.
+        const seriesPublisher = seriesValue?.startsWith("NBS") ? "NBS" : undefined;
         if (isObj(h["supplement_date_range"])) {
             const range = h["supplement_date_range"];
-            const identifier = this.build({ series: seriesValue }, "short");
+            const identifier = this.build({ series: seriesValue, publisher: seriesPublisher }, "short");
             const ms = s(range["supp_month_start"]);
             const ys = s(range["supp_year_start"]);
             const me = s(range["supp_month_end"]);
@@ -1109,7 +1113,7 @@ class NistBuilder {
             });
             return identifier;
         }
-        const base = this.buildCircularSupplementBase(h, seriesValue);
+        const base = this.buildCircularSupplementBase(h, seriesValue, seriesPublisher);
         const self = base;
         const raw = h["supplement_month_year"] !== undefined
             ? s(h["supplement_month_year"])
@@ -1119,11 +1123,11 @@ class NistBuilder {
         self["supplement"] = NistSupplement.fromRaw(raw);
         return base;
     }
-    buildCircularSupplementBase(h, seriesValue) {
+    buildCircularSupplementBase(h, seriesValue, seriesPublisher) {
         const basePortion = h["base_portion"];
         if (!isObj(basePortion)) {
             return this.build({
-                publisher: s(h["publisher"]),
+                publisher: s(h["publisher"]) ?? seriesPublisher,
                 series: seriesValue ?? s(h["series"]),
                 first_number: s(h["first_number"]),
             }, s(h["parsed_format"]) ?? "short");

package/dist/flavors/nist/model.js

@@ -516,11 +516,18 @@ export class NistIdentifier extends BaseIdentifier {
         else if (this.volume !== undefined && this.issue_number !== undefined) {
             result += `${this.volume.render()}n${this.issue_number.number}`;
         }
-        if (this.edition !== undefined)
-            result += this.edition.render();
+        // With a number the edition glues per the NIST spec ("800-53r5");
+        // series-only editions take a dot separator ("NBS.CIRC.e2" — the
+        // attested raw spelling; testsuite#5 C4/C5).
+        if (this.edition !== undefined) {
+            result += this.number !== undefined ? this.edition.render() : `.${this.edition.render()}`;
+        }
         if (this.version_component !== undefined)
             result += this.version_component.render();
-        result += this.supplementShort();
+        // A series-only supplement takes the dot itself ("NBS.CIRC.sup").
+        if (this.supplement !== undefined) {
+            result += this.number !== undefined ? this.supplementShort() : `.${this.supplementShort()}`;
+        }
         if (this.update_component !== undefined)
             result += this.update_component.render("mr");
         if (this.stage !== undefined) {

package/dist/flavors/oiml/implementation.js

@@ -14,6 +14,22 @@ function flavorOf(input) {
  */
 export function oimlGrammarImplementation() {
     return {
+        // Inverse of OimlUrnGenerator (lib/pubid/oiml/urn_parser.rb): strip the
+        // "urn:oiml:" namespace, rebuild the human head "OIML <TYPE> <locator>",
+        // and re-parse. Mirrors the reference exactly — the year and language
+        // URN segments are not carried back (the reference parser reads only
+        // the type and the number-part locator).
+        parseUrn(urn) {
+            const body = urn.replace(/^urn:oiml:/i, "");
+            const parts = body.split(":");
+            const typeToken = parts[0] ?? "";
+            const number = parts[1];
+            const displayType = typeToken.toLowerCase() === "bulletin" ? "Bulletin" : typeToken.toUpperCase();
+            let text = `OIML ${displayType}`;
+            if (number !== undefined && number !== "")
+                text += ` ${number}`;
+            return this.parse(text);
+        },
         parse(input) {
             // The co-published form carries both identifiers joined by "|":
             // "ISO 4064-1:2024|OIML R 49-1:2024". The first side is another

package/dist/urn/parsers.d.ts

@@ -0,0 +1,5 @@
+import type { Identifier } from "../conformance/implementation.js";
+import { type UrnParserDef } from "./types.js";
+export declare const URN_PARSERS: Record<string, UrnParserDef>;
+export declare function lookupUrnParser(flavor: string): UrnParserDef | undefined;
+export declare function parseUrnFor(def: UrnParserDef, urn: string, parse: (text: string) => Identifier): Identifier;

package/dist/urn/parsers.js

@@ -0,0 +1,566 @@
+import { splitParts, withYear } from "./types.js";
+import { grammarImplementation } from "../flavors/index.js";
+import { NationalAdoption } from "../flavors/evs/model.js";
+// Each parser mirrors lib/pubid/<flavor>/urn_parser.rb#parse_urn exactly —
+// including its lossiness (dropped segments stay dropped) and its error
+// cases. The parity fixture (test/fixtures/urn-parity.json) pins the
+// reference behavior for ~93k corpus URNs.
+export const URN_PARSERS = {
+    // lib/pubid/ansi/urn_parser.rb
+    ansi: {
+        prefix: "urn:ansi:",
+        reconstruct(body, parse) {
+            const [code, year] = splitParts(body);
+            return parse(withYear(`ANSI ${code}`, year));
+        },
+    },
+    // lib/pubid/ccsds/urn_parser.rb — the body is the full suffix.
+    ccsds: {
+        prefix: "urn:ccsds:",
+        reconstruct(body, parse) {
+            // The reference rejects cor-supplemented forms at its text parser;
+            // mirrored (fixture-pinned gap).
+            if (/:cor\./.test(body)) {
+                throw new Error(`CCSDS URN rejected by the reference: ${JSON.stringify(body)}`);
+            }
+            return parse(`CCSDS ${body}`);
+        },
+    },
+    // lib/pubid/cen_cenelec/urn_parser.rb — namespace "cen"; type token
+    // uppercased before the number.
+    cen_cenelec: {
+        prefix: "urn:cen:",
+        reconstruct(body, parse) {
+            const [typeToken = "", number, year] = splitParts(body);
+            return parse(withYear(`${typeToken.toUpperCase()} ${number}`, year));
+        },
+    },
+    // lib/pubid/cie/urn_parser.rb — leading lowercase publisher + trailing
+    // "sep.<x>" separator tokens are dropped.
+    cie: {
+        prefix: "urn:cie:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body).filter((p) => !p.startsWith("sep."));
+            const [, code, year] = parts;
+            return parse(withYear(`CIE ${code}`, year));
+        },
+    },
+    // lib/pubid/ashrae/urn_parser.rb — "ASHRAE Standard <number>-<year>".
+    ashrae: {
+        prefix: "urn:ashrae:",
+        reconstruct(body, parse) {
+            const [number, year] = splitParts(body);
+            let text = `ASHRAE Standard ${number}`;
+            if (year)
+                text += `-${year}`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/asme/urn_parser.rb — "ASME <code>-<year>".
+    asme: {
+        prefix: "urn:asme:",
+        reconstruct(body, parse) {
+            const [, code, year] = splitParts(body);
+            let text = `ASME ${code}`;
+            if (year)
+                text += `-${year}`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/astm/urn_parser.rb — year rendered to its last two digits.
+    astm: {
+        prefix: "urn:astm:",
+        reconstruct(body, parse) {
+            const [, code, year] = splitParts(body);
+            let text = `ASTM ${code}`;
+            if (year && year.length >= 2)
+                text += `-${year.slice(-2)}`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/iana/urn_parser.rb — "<registry>[/<sub-registry>]".
+    iana: {
+        prefix: "urn:iana:",
+        reconstruct(body, parse) {
+            const [registry = "", subRegistry] = splitParts(body);
+            return parse(subRegistry ? `${registry}/${subRegistry}` : registry);
+        },
+    },
+    // lib/pubid/idf/urn_parser.rb — empty segments dropped.
+    idf: {
+        prefix: "urn:idf:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body).filter((p) => p !== "");
+            const [number = "", year] = parts;
+            return parse(withYear(`IDF ${number}`, year));
+        },
+    },
+    // lib/pubid/plateau/urn_parser.rb — "PLATEAU <Type> #<number>[-<annex>]".
+    plateau: {
+        prefix: "urn:plateau:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const typeToken = parts[0] ?? "";
+            const number = parts[1] ?? "";
+            const annex = parts[2];
+            const typeMap = {
+                handbook: "Handbook",
+                tr: "Technical Report",
+                an: "Annex",
+            };
+            let text = `PLATEAU ${typeMap[typeToken] ?? (typeToken.charAt(0).toUpperCase() + typeToken.slice(1))} #${number}`;
+            if (annex)
+                text += `-${annex}`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/tgpp/urn_parser.rb — empty release/version segments dropped.
+    tgpp: {
+        prefix: "urn:3gpp:",
+        reconstruct(body, parse) {
+            const [type = "", code = "", release, version] = splitParts(body);
+            let result = `${type.toUpperCase()} ${code}`;
+            if (release !== undefined && release !== "")
+                result += `:${release}`;
+            if (version !== undefined && version !== "")
+                result += `/${version}`;
+            return parse(result);
+        },
+    },
+    // lib/pubid/w3c/urn_parser.rb — a known type token hyphenates the rest.
+    w3c: {
+        prefix: "urn:w3c:",
+        reconstruct(body, parse) {
+            const known = ["note", "dnote", "wd", "cr", "crd", "rec", "pr", "per", "spsd", "obsl"];
+            const parts = splitParts(body);
+            let text;
+            if (parts.length > 1 && known.includes(parts[0] ?? "")) {
+                text = `W3C ${parts.shift().toUpperCase()}-${parts.shift() ?? ""}`;
+            }
+            else {
+                text = `W3C ${parts.shift()}`;
+            }
+            if (parts.length)
+                text += `-${parts.shift()}`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/xsf/urn_parser.rb — "XEP <number>".
+    xsf: {
+        prefix: "urn:xsf:",
+        reconstruct(body, parse) {
+            const [, number] = splitParts(body);
+            return parse(`XEP ${number}`);
+        },
+    },
+    // lib/pubid/calconnect/urn_parser.rb — "CC[/series] <number>:<date>".
+    calconnect: {
+        prefix: "urn:calconnect:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const date = parts.pop();
+            const number = parts.pop();
+            const series = parts.pop();
+            let text = "CC";
+            if (series !== undefined)
+                text += `/${series}`;
+            text += ` ${number}:${date}`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/api/urn_parser.rb — "API STD <number>[-<part>]:<year>".
+    api: {
+        prefix: "urn:api:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const number = parts[1] ?? "";
+            let idx = 2;
+            let part = "";
+            if (parts[idx]?.startsWith("-")) {
+                part = parts[idx] ?? "";
+                idx += 1;
+            }
+            const year = parts[idx];
+            let text = `API STD ${number}${part}`;
+            if (year)
+                text += `:${year}`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/jis/urn_parser.rb — "JIS <code>[:<year>]".
+    jis: {
+        prefix: "urn:jis:",
+        reconstruct(body, parse) {
+            const [code = "", year] = splitParts(body);
+            return parse(withYear(`JIS ${code}`, year));
+        },
+    },
+    // lib/pubid/ietf/urn_parser.rb — rfc/bcp/std/fyi/id; unknown types raise.
+    ietf: {
+        prefix: "urn:ietf:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const type = parts.shift() ?? "";
+            let text;
+            if (type === "rfc") {
+                text = `RFC ${parts[0] ?? ""}`;
+            }
+            else if (type === "bcp" || type === "std" || type === "fyi") {
+                text = `${type.toUpperCase()} ${parts[0] ?? ""}`;
+            }
+            else if (type === "id") {
+                const [name, version] = parts;
+                text = version ? `${name}-${version}` : (name ?? "");
+            }
+            else {
+                throw new Error(`Invalid IETF URN type: ${JSON.stringify(type)}`);
+            }
+            return parse(text);
+        },
+    },
+    // lib/pubid/ecma/urn_parser.rb — optional tr/mem tag, labelled
+    // part-/ed-/vol- segments.
+    ecma: {
+        prefix: "urn:ecma:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const tag = parts[0] === "tr" || parts[0] === "mem" ? parts.shift() : undefined;
+            const number = parts.shift() ?? "";
+            const shiftLabelled = (label) => parts[0]?.startsWith(label) ? parts.shift().slice(label.length) : undefined;
+            const part = shiftLabelled("part-");
+            const edition = shiftLabelled("ed-");
+            const volume = shiftLabelled("vol-");
+            let base;
+            if (tag === "tr")
+                base = `ECMA TR/${number}`;
+            else if (tag === "mem")
+                base = `ECMA MEM/${number}`;
+            else
+                base = part ? `ECMA-${number}-${part}` : `ECMA-${number}`;
+            if (edition)
+                base += ` ed${edition}`;
+            if (volume)
+                base += ` vol${volume}`;
+            return parse(base);
+        },
+    },
+    // lib/pubid/gost/urn_parser.rb — "r" prefix selects the national
+    // standard; both classes render "GOST [R ]<number>-<year>".
+    gost: {
+        prefix: "urn:gost:std:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            if (parts[0] === "r") {
+                const number = parts[1] ?? "";
+                const year = parts[2];
+                return parse(year ? `GOST R ${number}-${year}` : `GOST R ${number}`);
+            }
+            const number = parts[0] ?? "";
+            const year = parts[1];
+            return parse(year ? `GOST ${number}-${year}` : `GOST ${number}`);
+        },
+    },
+    // lib/pubid/iho/urn_parser.rb — "IHO <TYPE>-<number> [<Part label>
+    // <value>] [<version>]".
+    iho: {
+        prefix: "urn:iho:",
+        reconstruct(body, parse) {
+            const partLabels = {
+                part: "Part",
+                ap: "Ap.",
+                annex: "Annex",
+                suppl: "Suppl",
+            };
+            const parts = splitParts(body);
+            const typeToken = (parts[0] ?? "").toUpperCase();
+            const number = parts[1] ?? "";
+            let idx = 2;
+            let partLabel;
+            const kindToken = parts[idx];
+            if (kindToken !== undefined && /^[a-z]+\./i.test(kindToken)) {
+                const [kind = "", value = ""] = kindToken.split(".", 2);
+                const label = partLabels[kind.toLowerCase()] ?? (kind.charAt(0).toUpperCase() + kind.slice(1));
+                partLabel = `${label} ${value}`;
+                idx += 1;
+            }
+            const version = parts[idx];
+            let text = `IHO ${typeToken}-${number}`;
+            if (partLabel)
+                text += ` ${partLabel}`;
+            if (version)
+                text += ` ${version}`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/oasis/urn_parser.rb — %20/%5D decoded after the namespace.
+    oasis: {
+        prefix: "urn:oasis:",
+        reconstruct(body, parse) {
+            const slug = body.replace(/%20|%5D/g, (m) => (m === "%20" ? " " : "]"));
+            return parse(`OASIS ${slug}`);
+        },
+    },
+    // lib/pubid/ogc/urn_parser.rb — "<year>-<number>[<revision>]".
+    ogc: {
+        prefix: "urn:ogc:",
+        reconstruct(body, parse) {
+            const [year = "", number = "", revision] = splitParts(body);
+            let text = `${year}-${number}`;
+            if (revision !== undefined)
+                text += revision;
+            return parse(text);
+        },
+    },
+    // lib/pubid/amca/urn_parser.rb — keyed tokens (copub./rev./reaff./interp.),
+    // a bare numeric year, and a trailing type token.
+    amca: {
+        prefix: "urn:amca:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const number = parts.shift() ?? "";
+            const first = parts[0];
+            const year = first !== undefined && /^\d+$/.test(first) ? parts.shift() : undefined;
+            const keyed = {};
+            const keyedTokens = [];
+            for (const token of parts) {
+                if (token.includes(".")) {
+                    const [k, ...v] = token.split(".", 2);
+                    keyed[k] = v.join(".");
+                    keyedTokens.push(token);
+                }
+            }
+            const type = parts.filter((t) => !keyedTokens.includes(t)).pop();
+            const publisher = (keyed["copub"] ?? "amca").toUpperCase();
+            let text;
+            if (type === "interpretation") {
+                const code = keyed["interp"]?.toUpperCase();
+                text = [publisher, number, code, "Interp"].filter(Boolean).join(" ");
+            }
+            else {
+                const titles = {
+                    standard: "Standard",
+                    publication: "Publication",
+                };
+                text = [publisher, titles[type ?? ""], number].filter(Boolean).join(" ");
+                if (year)
+                    text += `-${year}`;
+                if (keyed["rev"])
+                    text += ` (Rev. ${keyed["rev"]})`;
+                if (keyed["reaff"])
+                    text += ` (R${keyed["reaff"]})`;
+            }
+            return parse(text);
+        },
+    },
+    // lib/pubid/itu/urn_parser.rb — "report" segment between sector and code
+    // marks an ITU-R Report; otherwise "ITU-<SECTOR> <code>".
+    itu: {
+        prefix: "urn:itu:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const sector = parts[0] ?? "";
+            if (parts[1] === "report") {
+                return parse(`Report ITU-${sector.toUpperCase()} ${parts[2] ?? ""}`);
+            }
+            return parse(`ITU-${sector.toUpperCase()} ${parts[1] ?? ""}`);
+        },
+    },
+    // lib/pubid/iala/urn_parser.rb — annex(-letter) / ed.<x> / single-letter
+    // language segments after the code.
+    iala: {
+        prefix: "urn:mrn:iala:pub:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const code = (parts.shift() ?? "").toUpperCase();
+            let annexForm;
+            let annexLetter;
+            let edition;
+            let language;
+            for (const seg of parts) {
+                const annexMatch = seg.match(/^annex(-([a-z]))?$/i);
+                if (annexMatch) {
+                    annexLetter = annexMatch[2]?.toUpperCase();
+                    annexForm = annexLetter ? "ANNEX" : "Annex";
+                }
+                else if (/^ed\.?/i.test(seg)) {
+                    edition = seg.replace(/^ed\.?/i, "");
+                }
+                else if (/^[a-z]$/i.test(seg)) {
+                    language = seg.toUpperCase();
+                }
+            }
+            let text = `IALA ${code}`;
+            if (annexForm)
+                text += ` ${annexForm}`;
+            if (annexLetter)
+                text += ` ${annexLetter}`;
+            if (edition)
+                text += ` Ed ${edition}`;
+            if (language)
+                text += ` (${language})`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/bsi/urn_parser.rb — publisher token + number + year +
+    // 3-segment supplement slices (amd/cor/add).
+    bsi: {
+        prefix: "urn:bsi:",
+        reconstruct(body, parse) {
+            const abbr = { amd: "Amd", cor: "Cor", add: "Add" };
+            const parts = splitParts(body);
+            const [publisherToken = "", number = "", year, ...supplementParts] = parts;
+            let text = `${publisherToken.toUpperCase()} ${number}`;
+            if (year)
+                text += `:${year}`;
+            for (let i = 0; i < supplementParts.length; i += 3) {
+                const type = supplementParts[i] ?? "";
+                const num = supplementParts[i + 1];
+                const suppYear = supplementParts[i + 2];
+                const label = abbr[type.toLowerCase()] ?? (type.charAt(0).toUpperCase() + type.slice(1));
+                let suffix = num ? ` ${num}` : "";
+                if (suppYear)
+                    suffix += `:${suppYear}`;
+                text += `/${label}${suffix}`;
+            }
+            return parse(text);
+        },
+    },
+    // lib/pubid/csa/urn_parser.rb — format.<sep> token picks the year
+    // separator; the token itself is dropped.
+    csa: {
+        prefix: "urn:csa:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const separators = { dash: "-", colon: ":" };
+            const formatToken = parts.find((t) => t.startsWith("format."));
+            const separator = separators[(formatToken?.split(".")[1]) ?? ""] ?? "-";
+            const payload = parts.filter((t) => !t.startsWith("format."));
+            const [, code, year] = payload;
+            let text = `CSA ${code}`;
+            if (year)
+                text += `${separator}${year}`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/etsi/urn_parser.rb — "ETSI <TYPE> <code> [VERSION] [(date)]".
+    etsi: {
+        prefix: "urn:etsi:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const typeToken = (parts[0] ?? "").toUpperCase();
+            const code = parts[1] ?? "";
+            const version = parts[2];
+            const date = parts[3];
+            let text = `ETSI ${typeToken} ${code}`;
+            if (version !== undefined)
+                text += ` ${version.toUpperCase()}`;
+            if (date !== undefined)
+                text += ` (${date})`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/evs/urn_parser.rb — EN [org] number[:year] with an optional
+    // amd/cor iteration tail; the rebuilt text is parsed as a CEN adoption.
+    evs: {
+        prefix: "urn:evs:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const type = parts.shift() ?? "";
+            if (type.toLowerCase() !== "en") {
+                throw new Error(`unsupported type in ${JSON.stringify(body)}`);
+            }
+            const orgs = {
+                iso: "ISO",
+                "iso-iec": "ISO/IEC",
+                iec: "IEC",
+                cispr: "CISPR",
+            };
+            const orgParts = [];
+            while (parts[0] !== undefined && /^[a-z][a-z-]*$/.test(parts[0])) {
+                orgParts.push(parts.shift());
+            }
+            let text = "EN";
+            if (orgParts.length) {
+                const org = orgs[orgParts.join("-")];
+                if (org === undefined)
+                    throw new Error(`unknown adopted org in ${JSON.stringify(body)}`);
+                text += ` ${org}`;
+            }
+            const number = parts.shift();
+            if (number === undefined)
+                throw new Error(`missing number in ${JSON.stringify(body)}`);
+            text += ` ${number}`;
+            const year = parts.shift();
+            if (year)
+                text += `:${year}`;
+            if (parts.length) {
+                const yearTail = parts[parts.length - 1]?.match(/^\d{4}$/) ? parts.pop() : undefined;
+                const kind = parts.shift();
+                const iteration = parts.shift();
+                if (kind !== "amd" && kind !== "cor") {
+                    throw new Error(`malformed supplement in ${JSON.stringify(body)}`);
+                }
+                if (iteration === undefined || parts.length) {
+                    throw new Error(`malformed supplement in ${JSON.stringify(body)}`);
+                }
+                text += kind === "amd" ? `/A${iteration}` : `/AC${iteration}`;
+                if (yearTail)
+                    text += `:${yearTail}`;
+            }
+            // The reference constructs NationalAdoption around a parsed CEN
+            // base (lib/pubid/evs/urn_parser.rb) rather than re-parsing the
+            // rebuilt text as EVS.
+            const cen = grammarImplementation("cen_cenelec");
+            const base = cen.parse(text);
+            return new NationalAdoption({ base });
+        },
+    },
+    // lib/pubid/nist/urn_parser.rb — type token upcased via the reference
+    // map; ".supp" stripped; ".r<N>" revision suffix split off the payload.
+    nist: {
+        prefix: "urn:nist:",
+        reconstruct(body, parse) {
+            const typeUpcase = {
+                sp: "SP", fips: "FIPS", ir: "IR", nistcir: "NISTCIR", nbs: "NBS",
+                nistir: "NISTIR", csf: "CSF", gcr: "GCR", itl: "ITL", jres: "JRES",
+                lcirc: "LCIRC", mon: "MONO", ms: "MS", nsrds: "NSRDS", tn: "TN",
+                wp: "WP",
+            };
+            const parts = splitParts(body);
+            const typeToken = parts[0] ?? "";
+            const payload = parts[1] ?? "";
+            const label = typeUpcase[typeToken.toLowerCase()] ?? typeToken.toUpperCase();
+            const stripped = payload.replace(/\.supp$/, "");
+            const revMatch = stripped.match(/^(.*)\.(r\d+)$/i);
+            const code = revMatch ? revMatch[1] : stripped;
+            const revision = revMatch ? revMatch[2] : undefined;
+            let text = `NIST ${label} ${code}`;
+            if (revision)
+                text += revision;
+            return parse(text);
+        },
+    },
+    // lib/pubid/ieee/urn_parser.rb — "IEEE Std <code>[-<year>]". The fixture
+    // pins the reference's own parse failures for narrative/artifact rows.
+    ieee: {
+        prefix: "urn:ieee:",
+        reconstruct(body, parse) {
+            const parts = splitParts(body);
+            const [, code, year] = parts;
+            let text = `IEEE Std ${code}`;
+            if (year)
+                text += `-${year}`;
+            return parse(text);
+        },
+    },
+};
+export function lookupUrnParser(flavor) {
+    return URN_PARSERS[flavor];
+}
+export function parseUrnFor(def, urn, parse) {
+    const prefix = def.prefix;
+    if (!urn.toLowerCase().startsWith(prefix)) {
+        throw new Error(`Invalid ${def.prefix.toUpperCase()} URN: ${JSON.stringify(urn)}`);
+    }
+    return def.reconstruct(urn.slice(prefix.length), parse);
+}

package/dist/urn/types.d.ts

@@ -0,0 +1,12 @@
+import type { Identifier } from "../conformance/implementation.js";
+export type UrnParserDef = {
+    /** Full URN prefix including the trailing colon
+     *  (gem UrnParser PREFIX / "urn:" + flavor_name + ":"). */
+    prefix: string;
+    /** Rebuild the human text (or parse directly) from the URN body. */
+    reconstruct: (body: string, parse: (text: string) => Identifier) => Identifier;
+};
+/** Split the body on ":" (gem Base#split_parts). */
+export declare function splitParts(body: string): string[];
+/** Reconstruct "<TEXT>:<year>" (the common trailing-year shape). */
+export declare function withYear(text: string, year: string | undefined): string;

package/dist/urn/types.js

@@ -0,0 +1,8 @@
+/** Split the body on ":" (gem Base#split_parts). */
+export function splitParts(body) {
+    return body.split(":");
+}
+/** Reconstruct "<TEXT>:<year>" (the common trailing-year shape). */
+export function withYear(text, year) {
+    return year ? `${text}:${year}` : text;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pubid/pubid",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "TypeScript PubID identifiers: resolution, normalization and canonical hashes for every identifier in the pubid-testsuite corpus (41 standards bodies), with a conformance runner mirroring the Ruby reference",
   "type": "module",
   "license": "MIT",