@pubid/pubid 0.1.4 → 0.1.6

package/dist/flavors/ieee/model.js

@@ -126,6 +126,8 @@ const DRAFT_MONTH_NAMES = {
 export class IeeeDraft {
     version;
     revision;
+    isoStage;
+    isoIteration;
     year;
     month;
     day;
@@ -137,6 +139,8 @@ export class IeeeDraft {
         this.commaBeforeMonthSet = "comma_before_month" in attrs;
         this.version = String(attrs["version"] ?? "");
         this.revision = attrs["revision"];
+        this.isoStage = attrs["iso_stage"];
+        this.isoIteration = attrs["iso_iteration"];
         this.year = attrs["year"];
         this.originalMonth = attrs["month"];
         this.month = attrs["month"] !== undefined
@@ -155,24 +159,45 @@ export class IeeeDraft {
             body = body.slice(1);
         else if (body.startsWith("D") && body.length > 1)
             body = body.slice(1);
+        // The compound stage suffix (docs/IEEE-DRAFT-STAGES.md §1.3):
+        // "=DIS.3" is canonical - D (draft) = DIS (the stage), iteration 3.
+        // "=DDIS.3", "=DDIS3", "=DDIS-3" (the stage echoed with its own D)
+        // are accepted aliases. Captures [stage, iteration].
+        const compound = /=D?(PWI|NP|WD|CDV|FDIS|DIS|CD)(?:[.-]?(\d+))?$/;
+        let isoStage;
+        let isoIteration;
+        const cm = compound.exec(body);
+        if (cm !== null) {
+            isoStage = cm[1];
+            isoIteration = cm[2];
+            body = body.slice(0, cm.index);
+        }
         const monthAlt = Object.keys(DRAFT_MONTH_NAMES)
             .sort((a, b) => b.length - a.length)
             .map((m) => `${m.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.?`)
             .join("|");
         const suffix = new RegExp(`(?:(, | )(${monthAlt})(?: (\\d{1,2}))?(?:, | )| )((?:19|20)\\d{2}[a-z]{0,2})$`);
         const m = suffix.exec(body);
-        if (m === null)
-            return new IeeeDraft({ version: body });
+        if (m === null) {
+            return new IeeeDraft({ version: body, iso_stage: isoStage, iso_iteration: isoIteration });
+        }
         return new IeeeDraft({
             version: body.slice(0, m.index),
             month: m[2],
             day: m[3],
             year: m[4],
             comma_before_month: m[1] === ", ",
+            iso_stage: isoStage,
+            iso_iteration: isoIteration,
         });
     }
     render() {
         let result = `/D${this.version}`;
+        if (this.isoStage !== undefined)
+            result += `=${this.isoStage}`;
+        if (this.isoStage !== undefined && this.isoIteration !== undefined) {
+            result += `.${this.isoIteration}`;
+        }
         if (this.revision !== undefined)
             result += `.${this.revision}`;
         if (this.year !== undefined) {
@@ -432,10 +457,14 @@ export function renderIeeeBase(id) {
     const iecIeeOnly = id.publisher === "IEC" && JSON.stringify(id.copublisher) === '["IEEE"]';
     if (codeObj !== undefined) {
         let result = codeObj.render();
-        // A draft-carrying ISO-led joint reference prints P-less.
-        if (id.publisher === "ISO" && draftObj !== undefined)
-            result = result.replace(/^P/, "");
-        if (stageObj?.projectStatus === true && shouldRenderType && !result.startsWith("P")) {
+        // Prepend P if this is a project AND code doesn't already have P.
+        // A recorded project marker (the source spelled the P on a
+        // non-IEEE-led publisher) prints regardless of the publisher.
+        if ((stageObj?.projectStatus === true && shouldRenderType ||
+            id.constructor.polymorphicName ===
+                "pubid:ieee:project-draft-identifier" &&
+                id["project_marker"] === true) &&
+            !result.startsWith("P")) {
             result = `P${result}`;
         }
         if (id.year !== undefined && draftObj === undefined && id.edition === undefined && id.month === undefined) {
@@ -560,6 +589,12 @@ class IeeeUrnGenerator extends BaseUrnGenerator {
         return SPECIAL_URN_OF(this.identifier);
     }
     publisherComponent() {
+        // The IEC/IEEE co-published pair is definitional to the class and
+        // was previously lost ("urn:ieee:ieee" — no number, no draft).
+        if (this.identifier.constructor.polymorphicName ===
+            "pubid:ieee:iec-ieee-copublished") {
+            return "iec-ieee";
+        }
         // Supplements delegate #publisher/#copublisher to their base (Ruby
         // SupplementIdentifier); DualPublished derives publisher from BOTH
         // members; MultiNumbered derives it from its primary.
@@ -589,12 +624,35 @@ class IeeeUrnGenerator extends BaseUrnGenerator {
         return pub;
     }
     typeComponent() {
+        // A joint stage draft carries the stage in its draft clause and the
+        // project P inside the code — a separate type segment would
+        // duplicate both.
+        const jointDraft = this.identifier["ieee_draft"];
+        if (jointDraft !== undefined && jointDraft.startsWith("D="))
+            return undefined;
         const type = this.identifier.type;
         if (type === undefined || type.trim() === "" || type === "Std")
             return undefined;
         return type.toLowerCase().replaceAll(" ", ".");
     }
     codeComponent() {
+        const id = this.identifier;
+        // The co-published code is number+parts+separators (no year — its
+        // own segment), e.g. "61886-1".
+        if (id.constructor.polymorphicName ===
+            "pubid:ieee:iec-ieee-copublished") {
+            const self = id;
+            const number = self["number"];
+            if (number === undefined || number === "")
+                return undefined;
+            const parts = self["parts"] ?? [];
+            const separators = self["separators"] ?? [];
+            let code = number;
+            separators.forEach((sep, i) => {
+                code += `${sep}${parts[i] ?? ""}`;
+            });
+            return code;
+        }
         // Wrappers delegate code_obj to the identifier they wrap (Ruby
         // AdoptedStandard/CsaDualPublished/MultiNumberedIdentifier).
         const self = this.identifier;
@@ -615,6 +673,17 @@ class IeeeUrnGenerator extends BaseUrnGenerator {
         return root === id ? undefined : root.yearForUrn();
     }
     draftComponent() {
+        // The joint stage draft's stage rides in its ieee_draft clause
+        // ("D=CDV[:2020]"), emitted directly as the draft segment.
+        const jointDraft = this.identifier["ieee_draft"];
+        if (jointDraft !== undefined && jointDraft.startsWith("D="))
+            return `draft.${jointDraft}`;
+        const draftInfo = this.identifier["draft_info"];
+        if (draftInfo !== undefined &&
+            this.identifier.constructor.polymorphicName ===
+                "pubid:ieee:iec-ieee-copublished") {
+            return draftInfo === "" ? undefined : `draft.${draftInfo}`;
+        }
         const draftObj = this.identifier.draftObject();
         return draftObj === undefined ? undefined : `draft.${draftObj.render()}`;
     }
@@ -738,7 +807,13 @@ export const SupplementBaseDefs = {
     base: { type: IeeeIdentifier },
 };
 export const StandardClass = ieeeClass({ kind: "standard" }, { codeColumns: true });
-export const ProjectDraftIdentifierClass = ieeeClass({ kind: "project-draft-identifier" }, { codeColumns: true });
+export const ProjectDraftIdentifierClass = ieeeClass({ kind: "project-draft-identifier" }, {
+    codeColumns: true,
+    extraDefs: {
+        project_marker: { type: "boolean", default: false },
+    },
+    extraMappings: keyValue({ wire: "project_marker", to: "project_marker" }),
+});
 export const SiStandardClass = ieeeClass({ kind: "si-standard" }, {
     codeColumns: true,
     specialUrn: "si",
@@ -940,8 +1015,9 @@ export const JointDevelopmentClass = ieeeClass({ kind: "joint-development" }, {
         lead_party: { type: "string" },
         iso_stage: { type: "string" },
         ieee_draft: { type: "string" },
+        parenthetical_content: { type: "string" },
     },
-    extraMappings: keyValue({ wire: "publishers", to: "publishers" }, { wire: "lead_party", to: "lead_party" }, { wire: "iso_stage", to: "iso_stage" }, { wire: "ieee_draft", to: "ieee_draft" }),
+    extraMappings: keyValue({ wire: "publishers", to: "publishers" }, { wire: "lead_party", to: "lead_party" }, { wire: "iso_stage", to: "iso_stage" }, { wire: "ieee_draft", to: "ieee_draft" }, { wire: "parenthetical_content", to: "parenthetical_content" }),
     wireDelete: { keys: ["publisher", "copublisher"] },
     render: (id) => {
         const publishers = id["publishers"];
@@ -951,6 +1027,9 @@ export const JointDevelopmentClass = ieeeClass({ kind: "joint-development" }, {
         const codeObj = id.codeObj;
         // ISO-led renders the ISO format ALWAYS (the stage-less published
         // form "ISO/IEC/IEEE 12207.2:2020" prints colon-year, no stage).
+        // IEEE semantics: P = project (a draft); no P = a standard. The
+        // P-state is identity-bearing and prints as spelled - it is never
+        // added or stripped here.
         if (leadParty === "ISO") {
             const parts = [];
             if (publishers !== undefined && publishers.length > 0)
@@ -961,21 +1040,31 @@ export const JointDevelopmentClass = ieeeClass({ kind: "joint-development" }, {
             else if (isoStage !== undefined) {
                 parts.push(isoStage);
             }
-            let codeStr = codeObj?.render().replace(/^P/, "") ?? "";
+            const codeStr = codeObj?.render() ?? "";
             if (codeStr !== "")
                 parts.push(codeStr);
             let result = parts.join(" ");
             if (id.year !== undefined)
                 result += `:${id.year}`;
+            // The joint stage-draft clause ("D=WD.5") rides after the year in
+            // the ISO-led print; only the bare language/edition marker ("(E)")
+            // prints - a relationship narrative is metadata, not identity.
+            const jointDraft = id["ieee_draft"];
+            if (jointDraft !== undefined && jointDraft.startsWith("D="))
+                result += `/${jointDraft}`;
+            const marker = id["parenthetical_content"];
+            if (marker !== undefined && /^[A-Z](?:\s*[/&]\s*[A-Z])*$/.test(marker)) {
+                result += ` (${marker})`;
+            }
             return result;
         }
         // IEEE format
         const parts = [];
         if (publishers !== undefined && publishers.length > 0)
             parts.push(publishers.join("/"));
-        let codeStr = codeObj?.render().replace(/^P/, "") ?? "";
-        if (id.typed_stage?.projectStatus === true || id.type === "P")
-            codeStr = `P${codeStr}`;
+        // The P-state prints as spelled (P = project draft; no P =
+        // standard). Never added or stripped.
+        let codeStr = codeObj?.render() ?? "";
         if (ieeeDraft !== undefined)
             codeStr += `/${ieeeDraft}`;
         else if (id.typed_stage?.ieeeDraftEquivalent !== undefined) {

package/dist/flavors/ieee/update_codes.js

@@ -110,15 +110,21 @@ export const UPDATE_CODES = [
     { plain: "ISO/IEC/IEEE/P16085_DIS, March 2020", replacement: "ISO/IEC/IEEE DIS P16085-2020-03" },
     { plain: "ANSI/IEEE Std: Outdoor Apparatus Bushings", replacement: "ANSI/IEEE Std 21-1976-11" },
     { plain: "Draft National Electrical Safety Code, January 2016", replacement: "IEEE PC2-2016-01" },
-    { plain: "International Standard ISO/IEC 8802-9: 1996(E) ANSI/IEEE Std 802.9, 1996 Edition", replacement: "ISO/IEC/IEEE Std 802.9-1996" },
-    { plain: "ISO/IEC13210: 1994 (E) ANSI/IEEE Std 1003.3-1991", replacement: "ISO/IEC/IEEE 13210-1994" },
+    { plain: "International Standard ISO/IEC 8802-9: 1996(E) ANSI/IEEE Std 802.9, 1996 Edition", replacement: "ISO/IEC 8802-9:1996(E); ANSI/IEEE Std 802.9, 1996 Edition" },
+    { plain: "ISO/IEC13210: 1994 (E) ANSI/IEEE Std 1003.3-1991", replacement: "ISO/IEC 13210:1994 (E); ANSI/IEEE Std 1003.3-1991" },
     { plain: "J-STD-016-1995", replacement: "IEEE 016-1995" },
     { plain: "Nuclear EQ Sourcebook and Supplement", replacement: "IEEE 7438946" },
     { plain: "PC37.30.2/D043 Rev 18, May 2015", replacement: "IEEE PC37.30-2/D-043/R-18-2015" },
     { plain: "IEEE/IEC P62582 CD2 proposal, May 2017", replacement: "IEEE/IEC CD2 P62582-2017-05" },
-    { plain: "ISO/IEC/IEEE P16326:201x WD.4a, July 2017", replacement: "ISO/IEC/IEEE P16326/D-4a-2017-07" },
+    { plain: "ISO/IEC/IEEE P16326:201x WD.4a, July 2017", replacement: "ISO/IEC/IEEE P16326:2017/D=WD.4a" },
     { plain: "ISO/IEC/IEEE CD.1 P21839, October 2017", replacement: "ISO/IEC/IEEE CD1 P21839-2017-10" },
-    { plain: "ISO/IEC/IEEE P16326:201x WD5, December 2017", replacement: "ISO/IEC/IEEE P16326/D-5-2017-12" },
+    { plain: "ISO/IEC/IEEE P16326:201x WD5, December 2017", replacement: "ISO/IEC/IEEE P16326:2017/D=WD.5" },
+    // The joint-publisher underscore drafts ("ISO /IEC/IEEE P24774_D1,
+    // February 2020") are the slash spellings ("/D1") of rows the ledger
+    // already pins as project drafts; the underscore form parsed through
+    // the printed-joint family and flipped the classification (pubid#430).
+    { pattern: "\\b(ISO ?\\/ ?IEC ?\\/ ?IEEE|IEC ?\\/ ?IEEE) (P\\d+)_D(\\d+), ([A-Z][a-z]+.?) (\\d{4})\\b", replacement: "\\1 \\2/D\\3, \\4, \\5" },
+    { pattern: "\\b(ISO ?\\/ ?IEC ?\\/ ?IEEE|IEC ?\\/ ?IEEE) (P\\d+)_D(\\d+)\\b", replacement: "\\1 \\2/D\\3" },
     { plain: "IEEE/ISO/IEC P42010.CD1-V1.0, April 2020", replacement: "IEEE/ISO/IEC CD1 P42010-2020-04" },
     { plain: "Unapproved Draft Std ISO/IEC FDIS 15288:2007(E) IEEE P15288/D3,", replacement: "ISO/IEC/IEEE FDIS Std P15288/D-3-2007" },
     { plain: "IS0/IEC/IEEE 8802-11:2012/Amd.5:2015(E) (Adoption of IEEE Std 802.11af-2014)", replacement: "ISO/IEC/IEEE 802.11/Amd5-2012" },

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/grammar.js

@@ -47,12 +47,15 @@ function buildRules() {
         .or(ref(rules, "annex_identifier"))
         .or(ref(rules, "plus_supplement_identifier"))
         .or(ref(rules, "trailing_supplement_identifier"))
+        .or(ref(rules, "cs_identifier"))
         .or(ref(rules, "bulletin_identifier"))
         .or(ref(rules, "base")));
     // Publisher - always "OIML"
     rule("publisher", () => str("OIML").as("publisher").then(ref(rules, "space")));
-    // Document type - single letter
-    rule("doc_type", () => match("[BDEGRSVX]").as("type").then(ref(rules, "space")));
+    // Document type - single letter. Strict family set: OIML publishes
+    // R D B G E V S documents (the estate grammar's family letters);
+    // any other letter is a rejection, not a flavor.
+    rule("doc_type", () => match("[BDEGRSV]").as("type").then(ref(rules, "space")));
     // Bulletin locator - structured YYYY[-II[-SS]]
     rule("bulletin_date", () => ref(rules, "space")
         .then(ref(rules, "year_digits").as("year"))
@@ -108,9 +111,14 @@ function buildRules() {
     rule("lang_single", () => match("[EFRXDSCAU]"));
     rule("lang_multi_oiml", () => str("PO").or(str("PT")).or(str("PE")).or(str("SR")));
     rule("lang_multi", () => match("[a-z]").repeat(2, 2));
+    // Full-word language markers as OIML prints them ("(Fra)", "(Eng)"),
+    // three or more letters, any case. Kept verbatim on the identifier;
+    // the URN lowercases.
+    rule("lang_word", () => match("[A-Za-z]").repeat(3));
     rule("language_code", () => ref(rules, "lang_single")
         .then(ref(rules, "slash"), ref(rules, "lang_single"))
         .or(ref(rules, "lang_multi_oiml"))
+        .or(ref(rules, "lang_word"))
         .or(ref(rules, "lang_single"))
         .or(ref(rules, "lang_multi"))
         .as("language"));
@@ -137,7 +145,25 @@ function buildRules() {
     rule("trailing_supplement_identifier", () => ref(rules, "base_without_language")
         .as("base")
         .then(str(" "), str("Amendment").or(str("Errata")).as("trailing_marker"))
-        .then(ref(rules, "language_portion").maybe().as("language")));
+        .then(str(" ").then(ref(rules, "digits").as("number")).maybe(), ref(rules, "language_portion").maybe().as("language")));
+    // OIML-CS certification-system documents. Two head spellings
+    // ("OIML-CS" / "OIML CS") and two family-number separators
+    // ("PD-05" / "PD 05"), an "Edition N" instead of a year, and an
+    // optional parenthesized trailing amendment - "(Amendment 1)".
+    rule("cs_identifier", () => str("OIML")
+        .as("publisher")
+        .then(ref(rules, "dash")
+        .then(str("CS"))
+        .or(str(" ").then(str("CS")))
+        .as("cs_series"))
+        .then(ref(rules, "space"))
+        .then(str("PD").or(str("OD")).or(str("CID")).as("cs_family"))
+        .then(ref(rules, "dash").or(str(" ")).as("cs_separator"))
+        .then(ref(rules, "digits").as("number"))
+        .then(str(" "), str("Edition"), str(" "), ref(rules, "digits").as("edition"))
+        .then(str(" ")
+        .then(ref(rules, "lparen"), str("Amendment"), str(" "), ref(rules, "digits").as("cs_amendment"), ref(rules, "rparen"))
+        .maybe()));
     rule("plus_supplement_identifier", () => ref(rules, "base_without_language")
         .as("base")
         .then(str("+"), str("Amendment").or(str("Errata")).as("plus_marker"))

package/dist/flavors/oiml/implementation.js

@@ -1,6 +1,12 @@
 import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
 import { oimlGrammar } from "./grammar.js";
-import { buildOimlIdentifier } from "./model.js";
+import { buildOimlIdentifier, OimlDualPublished } from "./model.js";
+import { grammarImplementation } from "../index.js";
+// The co-publisher prefix (only ISO confirmed so far; the gem routes via
+// Pubid.parse's prefix table).
+function flavorOf(input) {
+    return input.toUpperCase().startsWith("ISO ") ? "iso" : "iso";
+}
 /**
  * Grammar-backed OIML on the unified model: the model classes are
  * BaseIdentifier subclasses, so they satisfy the Identifier adapter
@@ -8,7 +14,46 @@ import { buildOimlIdentifier } from "./model.js";
  */
 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
+            // flavor's identifier (routed by prefix, the Ruby Pubid.parse
+            // counterpart); the second is the OIML side.
+            if (input.includes("|") && !input.startsWith("|") && !input.endsWith("|")) {
+                // Each side may be either flavor ("ISO …|OIML R …" and the
+                // reversed print): the OIML side parses through this grammar, the
+                // co-publisher's through its own (routed by prefix).
+                const parts = input.split("|");
+                const members = parts.map((part) => {
+                    const s = part.trim();
+                    if (s.toUpperCase().startsWith("OIML")) {
+                        return buildOimlIdentifier(parseGrammar(oimlGrammar, s));
+                    }
+                    const impl = grammarImplementation(flavorOf(s));
+                    if (impl === undefined)
+                        throw new ParseFailed(`OIML: no flavor for ${s}`, 0);
+                    return impl.parse(s);
+                });
+                if (members.length === 2 && members[0] !== undefined && members[1] !== undefined) {
+                    return new OimlDualPublished({ first: members[0], second: members[1] });
+                }
+            }
             return buildOimlIdentifier(parseGrammar(oimlGrammar, input));
         },
     };

package/dist/flavors/oiml/model.d.ts

@@ -1,4 +1,23 @@
 import type { Tree } from "../../grammar/engine.js";
 import { BaseIdentifier } from "../../model/identifier.js";
+import type { AttributeTable } from "../../model/attribute.js";
+declare abstract class OimlBase extends BaseIdentifier {
+    readonly publisher: string | undefined;
+    readonly language: string | undefined;
+    readonly parsed_format: string | undefined;
+    effectiveFormat(): "long" | "short";
+}
 /** ---- builder (lib/pubid/oiml/builder.rb) ---- */
+export declare class OimlDualPublished extends OimlBase {
+    static polymorphicName: string;
+    static get attributes(): AttributeTable;
+    static get mappings(): never[];
+    readonly first: BaseIdentifier;
+    readonly second: BaseIdentifier;
+    constructor(attrs?: Record<string, unknown>);
+    render(): string;
+    toUrn(): string;
+    root(): BaseIdentifier;
+}
 export declare function buildOimlIdentifier(tree: Tree): BaseIdentifier;
+export {};