@pubid/pubid 0.1.4 → 0.1.5

package/dist/flavors/gb/index.d.ts

@@ -18,7 +18,14 @@ export declare class GbIdentifier extends BaseIdentifier {
     readonly number: string;
     readonly part: string | undefined;
     readonly date: PubidDate | undefined;
-    readonly all_parts: boolean | undefined;
     render(): string;
 }
+export declare class GbAllPartsIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static get attributes(): import("../../model/attribute.js").AttributeTable;
+    static get mappings(): never[];
+    readonly identifiers: GbIdentifier[];
+    render(): string;
+    toUrn(): string;
+}
 export declare function gbGrammarImplementation(): FlavorImplementation;

package/dist/flavors/gb/index.js

@@ -53,9 +53,17 @@ export class GbIdentifier extends BaseIdentifier {
         mandate: { type: "string" },
         number: { type: "string" },
         part: { type: "string" },
-        all_parts: { type: "boolean", default: false },
     });
-    static mappings = keyValue({ wire: "publisher", to: "publisher" }, { wire: "mandate", to: "mandate" }, { wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "date", to: "date" }, { wire: "all_parts", to: "all_parts" });
+    static mappings = keyValue({
+        wire: "publisher",
+        to: "publisher",
+        // The flat wire form is the Publisher's body scalar; rebuild the
+        // component on deserialize (lutaml coerces it on the Ruby side).
+        fromWire: (hash) => {
+            const value = hash["publisher"];
+            return typeof value === "string" ? new Publisher({ body: value }) : value;
+        },
+    }, { wire: "mandate", to: "mandate" }, { wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "date", to: "date" });
     // GB's flat-scalar entry: the Publisher serializes as its body scalar.
     static flatScalarComponents = { publisher: "publisher" };
     static flatScalarFields = { publisher: "body" };
@@ -68,17 +76,56 @@ export class GbIdentifier extends BaseIdentifier {
             numberPortion += `.${this.part}`;
         if (this.date !== undefined && this.date.year !== undefined)
             numberPortion += `-${this.date.year}`;
-        let result = `${code} ${numberPortion}`;
-        if (this.all_parts)
-            result += " (all parts)";
-        return result;
+        return `${code} ${numberPortion}`;
     }
 }
 registerType(GbIdentifier);
+// The document a member names: without its part and its edition (the
+// attributes an all-parts reference ignores).
+function gbDocumentOf(member) {
+    const r = member;
+    return new GbIdentifier({
+        publisher: r["publisher"],
+        mandate: r["mandate"],
+        number: r["number"],
+    });
+}
+// "GB/T 5606 (all parts)" names every part of one document: the wrapper
+// holds the member identifiers (gem #433 - the mark is a class, not a
+// flag), renders the document plus the suffix, and URNs as the document.
+export class GbAllPartsIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:gb:all-parts";
+    static get attributes() {
+        return extendAttributes(BaseIdentifier, {
+            identifiers: { type: GbIdentifier, collection: true },
+        });
+    }
+    static get mappings() {
+        return [{ wire: "identifiers", to: "identifiers" }];
+    }
+    render() {
+        const first = this.identifiers[0];
+        return `${first === undefined ? "" : gbDocumentOf(first).render()} (all parts)`;
+    }
+    toUrn() {
+        const first = this.identifiers[0];
+        return gbDocumentOf(first).toUrn();
+    }
+}
+registerType(GbAllPartsIdentifier);
 class GbBuilder extends BaseBuilder {
     defaultIdentifierClass() {
         return GbIdentifier;
     }
+    build(tree) {
+        const id = super.build(tree);
+        if (tree["all_parts"] === undefined)
+            return id;
+        // "(all parts)" wraps the document it parsed.
+        return new GbAllPartsIdentifier({
+            identifiers: [id],
+        });
+    }
     cast(key, value) {
         if (key === "publisher_code") {
             // Split an inline /T or /Z mandate out of the code.
@@ -92,7 +139,8 @@ class GbBuilder extends BaseBuilder {
             return value === undefined || value === null ? null : { date: new PubidDate({ year: String(value) }) };
         }
         if (key === "all_parts") {
-            return { all_parts: String(value) !== "" };
+            // Presence marker only: the wrapper carries the members.
+            return value;
         }
         return value;
     }

package/dist/flavors/ieee/grammar.js

@@ -42,6 +42,10 @@ function buildRules() {
     const dashMaybe = () => dash.maybe();
     const monthName = () => literalAlternation(MONTHS);
     const absent = (p) => p.absent();
+    // The ISO/IEC draft-stage vocabulary of the D= notation
+    // (docs/IEEE-DRAFT-STAGES.md §1.2). Ordered so the longest token wins
+    // ("FDIS" over "DIS").
+    const stageVocab = () => literalAlternation(["FDIS", "CDV", "PWI", "DIS", "WD", "NP", "CD"]);
     rule("year_digits", () => str("19").or(str("20")).then(digit.repeat(2, 2)).then(lower.repeat(0, 2)).then(absent(digits)));
     rule("month_numeric", () => str("0").then(match("[1-9]")).or(str("1").then(match("[0-2]"))));
     rule("date_with_month_text", () => monthName().as("month").then(space).then(R("year_digits").as("year")));
@@ -128,6 +132,16 @@ function buildRules() {
     rule("draft", () => (ref(rules, "draft_prefix")
         .then(ref(rules, "draft_version").repeat(1, 2))
         .then(dot.then(digits.as("revision")).maybe())
+        .then(
+    // The compound both-systems form (docs/IEEE-DRAFT-STAGES.md
+    // §1.3): "=DDIS.3" - IEEE draft ordinal = draft of the ISO/IEC
+    // stage, with its iteration. The glued "=DDIS3" / "=DDIS-3"
+    // spellings are accepted aliases of "=DDIS.3".
+    str("=")
+        .then(str("D").then(stageVocab().as("draft_iso_stage"))
+        .or(stageVocab().as("draft_iso_stage")))
+        .then((dot.or(dash)).maybe().then(digits.as("draft_iso_iteration")).maybe())
+        .maybe())
         .then(ref(rules, "draft_date").maybe())).as("draft"));
     rule("revision_suffix", () => slash.then(str("R")).then(dash).then(match("[0-9A-Za-z]").repeat(1, Infinity).as("revision")));
     rule("edition", () => (comma.then(R("year_digits").as("edition_year")).then(str(" Edition"))).or(space.or(dash)
@@ -230,13 +244,38 @@ function buildRules() {
         .then(match("[^\\n]").repeat(1, Infinity).as("content")));
     rule("joint_development_ieee_format", () => literalAlternation(["ISO/IEC/IEEE", "ISO/IEEE", "IEC/IEEE", "IEEE/CSA"]).as("joint_publishers")
         .then(space)
-        .then(str("P"))
+        // P = project (the document is a draft): identity-bearing, so it
+        // is captured and preserved, never silently consumed.
+        .then(str("P").as("project_marker"))
         .then(digits.as("number"))
         .then((dot.or(dash)).then(digits.as("part")).maybe())
         .then(slash.then(digits).then(dot.then(digits).maybe())
         .then(dash.then(digits.as("draft_version")).maybe()).maybe())
-        .then(slash.then(str("D")).then(digits.as("draft_version"))
-        .or(comma.then(literalAlternation(["CDV", "FDIS", "CD", "DIS"]).as("iec_stage")).then(digits.maybe().as("stage_iteration"))).maybe())
+        .then(
+    // Variant 1b: the ordinal-less stage draft "D=CDV[:2020]" -
+    // D (draft) = CDV (the IEC stage it drafts). The year rides in
+    // the draft clause (a distinct key, so the builder keeps the
+    // date inside the designator).
+    slash.then(str("D")).then(str("="))
+        .then(stageVocab().as("draft_iso_stage"))
+        .then(str(":").then(R("year_digits").as("draft_stage_year")).maybe())
+        .or(
+    // Variant 1: /D8 notation (original), with the compound
+    // both-systems suffix "=DDIS.3" (docs/IEEE-DRAFT-STAGES.md
+    // §1.3). The doubled-D spelling is consumed and echoed: the
+    // joint form prints the stage as spelled.
+    slash.then(str("D")).then(digits.as("draft_version"))
+        .then(str("=")
+        .then(str("D").as("draft_stage_d").then(stageVocab().as("draft_iso_stage"))
+        .or(stageVocab().as("draft_iso_stage")))
+        .then((dot.or(dash)).maybe().then(digits.as("draft_iso_iteration")).maybe())
+        .maybe()))
+        .or(
+    // Variant 2: , CDV1 notation (comma before stage code) —
+    // the stage draft of the named ISO/IEC stage, its iteration
+    comma.then(literalAlternation(["CDV", "FDIS", "CD", "DIS"]).as("iec_stage"))
+        .then(digits.maybe().as("stage_iteration")))
+        .maybe())
         .then(ref(rules, "edition").maybe())
         .then((dash.then(R("year_digits").as("year"))).or(comma.maybe().then(space).then(monthName().as("month")).then(spaceMaybe())
         .then(R("year_digits").as("year"))).maybe())
@@ -270,14 +309,27 @@ function buildRules() {
             .then(isoStage().then(stdNoise()).then(space)
             .or(str("").as("iso_published").then(spaceMaybe())))
             .or(stagedOnly.as("joint_publishers").then(space).then(isoStage()).then(stdNoise()).then(space)))
-            .then(str("P").maybe())
+            .then(str("P").as("project_marker").maybe())
             .then(digits.as("number"))
             .then((dot.then(absent(R("year_digits"))).then(digits.as("part")))
             .or(dash.then(str("").as("part_dash")).then(absent(R("year_digits")))
             .then(digits.as("part")))
             .maybe())
             .then(dateClause())
-            .then((slash.then(str("D")).then(dashMaybe())
+            .then(
+        // The ISO/IEC edition marker may sit between the year and an
+        // amendment/draft tail ("8802.11:2012 (E)/Amd 1-2014").
+        (spaceMaybe().then(str("("))
+            .then(match("[^)]").repeat(1, Infinity).as("edition_marker"))
+            .then(str(")"))).maybe())
+            .then(
+        // The stage-draft clause of the ISO-led print: "/D=WD.5" - D
+        // (draft) = the ISO/IEC stage it drafts, with its iteration
+        // (docs/IEEE-DRAFT-STAGES.md §1.2).
+        (slash.then(str("D")).then(str("="))
+            .then(stageVocab().as("draft_iso_stage"))
+            .then(dot.then(digits.then(match("[A-Za-z]").repeat(0, 1)).as("draft_iso_iteration")).maybe()))
+            .or(slash.then(str("D")).then(dashMaybe())
             .then(match("[0-9.]").repeat(1, Infinity).as("draft_version"))
             .then(((comma.or(space)).then(monthName().as("draft_month")).then(space)
             .then(R("year_digits").as("draft_year"))).or(comma.then(R("year_digits").as("draft_year"))).maybe())).maybe())
@@ -288,12 +340,30 @@ function buildRules() {
             .then(ref(rules, "revision_suffix").maybe())
             .then(ref(rules, "parenthetical").maybe());
     });
+    // The stage-less ISO/IEC label with a colon year and the ISO/IEC
+    // edition marker: "ISO/IEC 13210:1994 (E)" - the ISO/IEC portion of a
+    // double-labeled standard. The (E) parenthetical is REQUIRED: without it
+    // this spelling is the ISO flavor's own form and must not be stolen.
+    rule("joint_development_iso_iec_edition", () => str("ISO/IEC").as("joint_publishers")
+        .then(space)
+        .then(str("").as("iso_published"))
+        .then(str("P").as("project_marker").maybe())
+        .then(digits.as("number"))
+        // The part may be dot- or dash-joined ("8802-9"); a dash-year is
+        // not a part. A distinct key: the iso-format route's part_dash
+        // prints as a dot in the joint code; only the label keeps its dash.
+        .then((dot.then(digits.as("part")))
+        .or(dash.then(str("").as("iec_label_dash")).then(absent(R("year_digits"))).then(digits.as("part")))
+        .maybe())
+        .then(str(":").then(spaceMaybe()).then(R("year_digits").as("year")))
+        .then(spaceMaybe())
+        .then(ref(rules, "parenthetical")));
     rule("joint_development_embedded_stage", () => literalAlternation([
         "ISO/IEC/IEEE", "IEEE/ISO/IEC", "IEEE/IEC/ISO", "ISO/IEEE",
         "IEC/IEEE", "IEEE/IEC", "ISO/IEC", "IEEE",
     ]).as("joint_publishers")
         .then(space)
-        .then(str("P").maybe())
+        .then(str("P").as("project_marker").maybe())
         .then(digits.as("number"))
         .then((dot.or(dash)).then(absent(R("year_digits"))).then(digits.as("part")).maybe())
         .then(dot)
@@ -577,6 +647,7 @@ function buildRules() {
         .or(ref(rules, "conformance_identifier"))
         .or(ref(rules, "joint_development_ieee_format"))
         .or(ref(rules, "joint_development_iso_format"))
+        .or(ref(rules, "joint_development_iso_iec_edition"))
         .or(ref(rules, "joint_development_embedded_stage"))
         .or(ref(rules, "iec_ieee_copublished"))
         .or(ref(rules, "number_first_identifier"))

package/dist/flavors/ieee/index.js

@@ -121,6 +121,10 @@ class IeeeBuilder {
                     attributes["parts"] = codeObj.parts;
                 if (codeObj?.originalSeparator !== undefined)
                     attributes["separator"] = codeObj.originalSeparator;
+                // P = project (the document is a draft): the marker is
+                // identity-bearing, so stripping the letter must not strip the
+                // fact (docs/IEEE-DRAFT-STAGES.md §1.1).
+                attributes["project_marker"] = true;
             }
         }
         delete attributes["__code"];
@@ -298,11 +302,23 @@ class IeeeBuilder {
         return attributes;
     }
     determineStageAbbr(typeValue, parsed) {
+        // An explicit joint stage on the draft ("=DFDIS.3") IS the stage —
+        // it outranks the ordinal ladder, which classifies IEEE-internal
+        // drafts only (docs/IEEE-DRAFT-STAGES.md §1.3).
         if (parsed["draft"] !== undefined) {
             let draftData = parsed["draft"];
             if (Array.isArray(draftData)) {
                 draftData = mergeParsedArray(draftData);
             }
+            if (isObj(draftData) && draftData["draft_iso_stage"] !== undefined) {
+                const stage = extractValue(draftData["draft_iso_stage"]) ?? "";
+                // The doubled-D alias ("DFDIS") carries its own draft marker;
+                // the stage is what remains.
+                const rest = stage.slice(1);
+                return stage.startsWith("D") && ["PWI", "NP", "WD", "CD", "CDV", "DIS", "FDIS"].includes(rest)
+                    ? rest
+                    : stage;
+            }
             if (isObj(draftData) && draftData["draft_version"] !== undefined) {
                 const dv = draftData["draft_version"];
                 const version = Array.isArray(dv) ? dv.map((v) => extractValue(v) ?? "").join("") : extractValue(dv);
@@ -343,6 +359,8 @@ class IeeeBuilder {
         }
         let version;
         let revision;
+        let isoStage;
+        let isoIteration;
         let month;
         let year;
         let day;
@@ -355,6 +373,8 @@ class IeeeBuilder {
                     version = version.replace(/^-/, "");
             }
             revision = extractValue(draftData["revision"]);
+            isoStage = extractValue(draftData["draft_iso_stage"]);
+            isoIteration = extractValue(draftData["draft_iso_iteration"]);
             month = extractValue(draftData["month"]);
             year = extractValue(draftData["year"]);
             day = extractValue(draftData["day"]);
@@ -370,10 +390,12 @@ class IeeeBuilder {
         else {
             version = extractValue(draftData);
         }
-        if (version !== undefined) {
+        if (version !== undefined || (isObj(draftData) && draftData["draft_iso_stage"] !== undefined)) {
             const draftObj = new IeeeDraft({
                 version,
                 revision,
+                iso_stage: isoStage,
+                iso_iteration: isoIteration,
                 month,
                 year,
                 day,
@@ -601,7 +623,14 @@ class IeeeBuilder {
             codeParts.push(extractValue(parsed["part"]) ?? "");
         let codeStr = extractValue(parsed["number"]);
         if (codeStr !== undefined && codeParts.length > 0) {
-            codeStr += `.${codeParts.join(".")}`;
+            // The ISO/IEC label's part may be dash-joined ("8802-9") - keep the
+            // printed separator.
+            const sep = parsed["iec_label_dash"] !== undefined ? "-" : ".";
+            codeStr += `${sep}${codeParts.join(sep)}`;
+        }
+        // P = project (a draft): identity-bearing, preserved as spelled.
+        if (parsed["project_marker"] !== undefined && codeStr !== undefined) {
+            codeStr = `P${codeStr}`;
         }
         if (codeStr !== undefined) {
             const codeObj = IeeeCode.parse(codeStr);
@@ -639,6 +668,37 @@ class IeeeBuilder {
             if (draftVer !== "")
                 attributes["ieee_draft"] = `D${draftVer}`;
         }
+        // The "(E)" edition marker of an ISO/IEC label rides on the joint
+        // reference as parenthetical_content - either from the trailing
+        // parenthetical slot (the double-label form) or the mid-rule slot
+        // before an amendment tail.
+        const parenthetical = parsed["parameters"];
+        if (parenthetical !== undefined && typeof parenthetical === "object" && !Array.isArray(parenthetical)) {
+            const content = parenthetical["parenthetical_content"];
+            if (content !== undefined)
+                attributes["parenthetical_content"] = extractValue(content);
+        }
+        if (attributes["parenthetical_content"] === undefined && parsed["edition_marker"] !== undefined) {
+            attributes["parenthetical_content"] = extractValue(parsed["edition_marker"]);
+        }
+        // The joint stage-draft clause (docs/IEEE-DRAFT-STAGES.md §1.3):
+        // variant 1's compound tail composes onto the IEEE ordinal
+        // ("D5=DIS.3"); variant 1b is the ordinal-less stage draft whose
+        // date rides inside the designator ("D=CDV:2020"). The doubled-D
+        // alias spelling echoes as spelled.
+        if (parsed["draft_iso_stage"] !== undefined) {
+            const stageText = `${extractValue(parsed["draft_stage_d"]) ?? ""}${extractValue(parsed["draft_iso_stage"]) ?? ""}`;
+            let jointDraft = parsed["draft_version"] !== undefined
+                ? `D${(extractValue(parsed["draft_version"]) ?? "").replace(/^D/, "")}=${stageText}`
+                : `D=${stageText}`;
+            if (parsed["draft_iso_iteration"] !== undefined) {
+                jointDraft += `.${extractValue(parsed["draft_iso_iteration"])}`;
+            }
+            if (parsed["draft_stage_year"] !== undefined) {
+                jointDraft += `:${extractValue(parsed["draft_stage_year"])}`;
+            }
+            attributes["ieee_draft"] = jointDraft;
+        }
         // The catalogue-PRINTED joint form (dash-year / ", Month YYYY" /
         // date-trailing-the-draft / date-less parenthetical): a Standard
         // carrying publisher/copublisher renders it as printed; the colon-year
@@ -654,8 +714,11 @@ class IeeeBuilder {
                     typeof parsed["parameters"] === "object" && !Array.isArray(parsed["parameters"]) &&
                     parsed["parameters"]["parenthetical_content"] !== undefined))) {
             const sep = parsed["part_dash"] !== undefined ? "-" : ".";
-            const printedCode = [extractValue(parsed["number"]), extractValue(parsed["part"])]
+            let printedCode = [extractValue(parsed["number"]), extractValue(parsed["part"])]
                 .filter((x) => x !== undefined).join(sep);
+            // P = project: the marker is identity, preserved as spelled.
+            if (parsed["project_marker"] !== undefined)
+                printedCode = `P${printedCode}`;
             const printedAttrs = {
                 publisher: attributes["publisher"],
                 copublisher: attributes["copublisher"],
@@ -1022,7 +1085,16 @@ function copublishedStructured(copublishedNumber) {
 }
 // --- parse orchestration -------------------------------------------------------
 function ieeeParseSingle(input) {
-    const cleaned = preprocessIeee(applyUpdateCodes(input));
+    const normalized = applyUpdateCodes(input);
+    // UpdateCodes may introduce the "; " double-label separator (the
+    // ISO/IEC and IEEE labels of one document), but the dispatch ran on
+    // the raw input - re-dispatch so the dual construction sees it.
+    if (normalized !== input && normalized.includes("; ")) {
+        const re = preParse(normalized);
+        if (re.dispatch === "dual_semicolon")
+            return buildDual(re.parts);
+    }
+    const cleaned = preprocessIeee(normalized);
     const tree = parseGrammar(ieeeGrammar, cleaned);
     const builder = new IeeeBuilder();
     builder.originalInput = input;

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

@@ -43,6 +43,8 @@ export declare class IeeeCode {
 export declare class IeeeDraft {
     readonly version: string;
     readonly revision: string | undefined;
+    readonly isoStage: string | undefined;
+    readonly isoIteration: string | undefined;
     readonly year: string | undefined;
     readonly month: string | undefined;
     readonly day: string | undefined;

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/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
@@ -9,6 +15,29 @@ import { buildOimlIdentifier } from "./model.js";
 export function oimlGrammarImplementation() {
     return {
         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 {};

package/dist/flavors/oiml/model.js

@@ -1,5 +1,5 @@
 import { ParseFailed } from "../../grammar/engine.js";
-import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { BaseIdentifier, registerType, resolveType } from "../../model/identifier.js";
 import { extendAttributes, keyValue } from "../../model/attribute.js";
 import { BaseUrnGenerator } from "../../model/urn-generator.js";
 const KIND_BY_TYPE = {
@@ -13,6 +13,7 @@ const KIND_BY_TYPE = {
 };
 const TYPE_STRINGS = {
     "basic-publication": "B",
+    "certification-system": "CS",
     document: "D",
     "expert-report": "E",
     guide: "G",
@@ -108,6 +109,29 @@ class OimlSingle extends OimlBase {
         return result;
     }
 }
+/** ---- OIML-CS certification-system documents ---- */
+const CS_ATTRS = {
+    ...SINGLE_ATTRS,
+    family: { type: "string" },
+    amendment: { type: "string" },
+    space_separator: { type: "boolean", default: false },
+};
+const CS_MAPPINGS = keyValue(...Object.keys(CS_ATTRS).map((name) => ({ wire: name, to: name })));
+// "OIML-CS PD-05 Edition 6 (Amendment 1)": the number keeps its printed
+// zero padding; the print states an edition instead of a year.
+class OimlCertificationSystem extends OimlSingle {
+    static polymorphicName = "pubid:oiml:certification-system";
+    static attributes = extendAttributes(BaseIdentifier, CS_ATTRS);
+    static mappings = CS_MAPPINGS;
+    render() {
+        let result = `${this.publisher}-CS ${this.family}` +
+            `${this.space_separator ? " " : "-"}${this.number} Edition ${this.edition}`;
+        if (this.amendment)
+            result += ` (Amendment ${this.amendment})`;
+        return result;
+    }
+}
+registerType(OimlCertificationSystem);
 function oimlSingleClass(kind) {
     const isBulletin = kind === "bulletin";
     class OimlSingleIdentifier extends OimlSingle {
@@ -146,12 +170,13 @@ const SUPP_ATTRS = {
     parsed_format: { type: "string", default: "short" },
     base: { type: OimlSingle },
     supp_year: { type: "string" },
+    number: { type: "string" },
     trailing: { type: "boolean", default: false },
     joined: { type: "boolean", default: false },
     letter: { type: "string" },
     year_on_base: { type: "boolean", default: false },
 };
-const SUPP_MAPPINGS = keyValue({ wire: "language", to: "language" }, { wire: "parsed_format", to: "parsed_format" }, { wire: "base", to: "base" }, { wire: "year", to: "supp_year" }, { wire: "trailing", to: "trailing" }, { wire: "joined", to: "joined" }, { wire: "letter", to: "letter" }, { wire: "year_on_base", to: "year_on_base" });
+const SUPP_MAPPINGS = keyValue({ wire: "language", to: "language" }, { wire: "parsed_format", to: "parsed_format" }, { wire: "base", to: "base" }, { wire: "year", to: "supp_year" }, { wire: "number", to: "number" }, { wire: "trailing", to: "trailing" }, { wire: "joined", to: "joined" }, { wire: "letter", to: "letter" }, { wire: "year_on_base", to: "year_on_base" });
 /** ---- supplements (Amendment / Errata) and Annex ---- */
 class OimlSupplement extends OimlBase {
     supplementType() {
@@ -178,6 +203,8 @@ class OimlSupplement extends OimlBase {
         }
         if (this.trailing) {
             let result = `${stripLanguage(this.base.render())} ${this.supplementType()}`;
+            if (this.number)
+                result += ` ${this.number}`;
             if (this.language)
                 result += ` (${this.language})`;
             return result;
@@ -247,6 +274,7 @@ for (const kind of [
 ]) {
     KIND_CLASSES[kind] = oimlSingleClass(kind);
 }
+KIND_CLASSES["certification-system"] = OimlCertificationSystem;
 KIND_CLASSES["amendment"] = oimlSupplementClass("amendment");
 KIND_CLASSES["errata"] = oimlSupplementClass("errata");
 KIND_CLASSES["annex"] = oimlSupplementClass("annex");
@@ -270,6 +298,13 @@ class OimlUrnGenerator extends BaseUrnGenerator {
                 parts.push(id.language.toLowerCase());
             return parts.join(":");
         }
+        // Certification-system documents: the family-number pair is the
+        // document identity ("cs:pd-05"); the printed edition and trailing
+        // amendment are print states, not URN segments.
+        if (kind === "certification-system") {
+            const cs = id;
+            return ["urn", "oiml", "cs", `${(cs.family ?? "").toLowerCase()}-${cs.number ?? ""}`].join(":");
+        }
         const isSupp = kind === "amendment" || kind === "errata" || kind === "annex";
         const single = (isSupp ? id.base : id);
         const parts = ["urn", "oiml"];
@@ -280,8 +315,12 @@ class OimlUrnGenerator extends BaseUrnGenerator {
         const code = single.composedCode();
         if (code)
             parts.push(code);
+        // The trailing-word form keeps the publication year on the base
+        // ("R 138:2009 Amendment 1"); the supplement itself carries only the
+        // ordinal.
         const year = id.year ??
-            id.supp_year;
+            id.supp_year ??
+            (isSupp ? single.year : undefined);
         if (year)
             parts.push(year);
         const stage = id.stage;
@@ -292,6 +331,12 @@ class OimlUrnGenerator extends BaseUrnGenerator {
             parts.push(iteration);
         if (id.language)
             parts.push(id.language.toLowerCase());
+        // Ruby's supplement branch appends the ordinal after the language.
+        if (isSupp) {
+            const ordinal = id.number;
+            if (ordinal)
+                parts.push(ordinal);
+        }
         return parts.join(":");
     }
 }
@@ -299,15 +344,97 @@ for (const klass of Object.values(KIND_CLASSES)) {
     klass.urnGenerator = OimlUrnGenerator;
 }
 /** ---- builder (lib/pubid/oiml/builder.rb) ---- */
+// OIML co-publishes some documents jointly with another SDO (ISO so
+// far); the printed reference carries both identifiers joined by "|":
+// "ISO 4064-1:2024|OIML R 49-1:2024". The URN is the OIML side's.
+export class OimlDualPublished extends OimlBase {
+    static polymorphicName = "pubid:oiml:dual-published";
+    static get attributes() {
+        return extendAttributes(OimlBase, {
+            // "string" keeps objects passing through the scalar coercion
+            // untouched (the ieee AdoptedStandard precedent for cross-flavor
+            // members); the constructor coerces bare hashes via the registry.
+            first: { type: "string" },
+            second: { type: "string" },
+        });
+    }
+    static get mappings() {
+        return [
+            { wire: "first", to: "first" },
+            { wire: "second", to: "second" },
+        ];
+    }
+    constructor(attrs = {}) {
+        super(attrs);
+        // The members are cross-flavor (the co-publisher's side arrives as a
+        // bare hash with _type); coerce through the registry - the abstract
+        // BaseIdentifier attribute type cannot dispatch polymorphically.
+        const coerceMember = (v) => {
+            if (v instanceof BaseIdentifier)
+                return v;
+            if (typeof v === "object" && v !== null && "_type" in v) {
+                const klass = resolveType(v["_type"]);
+                if (klass !== undefined) {
+                    return klass.fromHash(v);
+                }
+            }
+            return undefined;
+        };
+        const self = this;
+        const f = coerceMember(self["first"]);
+        const s = coerceMember(self["second"]);
+        if (f !== undefined)
+            self["first"] = f;
+        if (s !== undefined)
+            self["second"] = s;
+    }
+    render() {
+        return `${this.first.toHuman()}|${this.second.toHuman()}`;
+    }
+    toUrn() {
+        // The URN is the OIML side's, whichever position it prints in.
+        const oimlSide = this.second instanceof OimlBase ? this.second : this.first;
+        return oimlSide.toUrn();
+    }
+    root() {
+        return this.second instanceof OimlBase ? this.second : this.first;
+    }
+}
+registerType(OimlDualPublished);
 export function buildOimlIdentifier(tree) {
     if (!isObj(tree))
         throw new ParseFailed("OIML: unexpected parse tree", 0);
+    if (tree["cs_series"] !== undefined)
+        return buildCs(tree);
     if (tree["amd_marker"] !== undefined)
         return buildShortAmendment(tree);
     if (tree["base"] !== undefined)
         return buildSupplement(tree);
     return buildBaseDocument(tree);
 }
+// OIML-CS documents: family (PD/OD/CID), zero-padded number, the
+// printed "Edition N", and an optional parenthesized trailing
+// amendment. The family-number separator is a spelling flag.
+function buildCs(tree) {
+    const attrs = {
+        publisher: str(tree["publisher"]) ?? "OIML",
+        parsed_format: "short",
+    };
+    const family = str(tree["cs_family"]);
+    if (family !== undefined)
+        attrs["family"] = family;
+    const number = str(tree["number"]);
+    if (number !== undefined)
+        attrs["number"] = number;
+    const edition = str(tree["edition"]);
+    if (edition !== undefined)
+        attrs["edition"] = edition;
+    const amendment = str(tree["cs_amendment"]);
+    if (amendment !== undefined)
+        attrs["amendment"] = amendment;
+    attrs["space_separator"] = tree["cs_separator"] === " ";
+    return new KIND_CLASSES["certification-system"](attrs);
+}
 function buildShortAmendment(tree) {
     const baseCode = isObj(tree["base_code"]) ? tree["base_code"] : undefined;
     const base = buildBaseDocument({
@@ -359,6 +486,9 @@ function buildSupplement(tree) {
     const language = extractLanguage(tree["language"]);
     if (language !== undefined)
         attrs["language"] = language;
+    const ordinal = str(tree["number"]);
+    if (ordinal !== undefined)
+        attrs["number"] = ordinal;
     if (marker !== undefined)
         attrs["trailing"] = true;
     if (plusMarker !== undefined)

package/dist/index.d.ts

@@ -6,3 +6,4 @@ export type { FlavorImplementation, Identifier, ImplementationRegistry } from ".
 export { PendingRegistry } from "./conformance/pending.js";
 export { checkCase, runFlavor, runCorpus } from "./conformance/runner.js";
 export { corpusModeImplementation, CorpusBackedIdentifier } from "./implementations/corpus-mode.js";
+export { grammarImplementation } from "./flavors/index.js";

package/dist/index.js

@@ -4,3 +4,6 @@ export { buildArtifact, loadBundledCorpus, parseArtifact, } from "./corpus/artif
 export { PendingRegistry } from "./conformance/pending.js";
 export { checkCase, runFlavor, runCorpus } from "./conformance/runner.js";
 export { corpusModeImplementation, CorpusBackedIdentifier } from "./implementations/corpus-mode.js";
+// Root re-export so consumers needn't deep-import flavor modules
+// (pubid/pubid-ts#63 - the estate serving codec).
+export { grammarImplementation } from "./flavors/index.js";

package/dist/model/identifier.d.ts

@@ -39,6 +39,7 @@ export type UrnGeneratorCtor = new (identifier: BaseIdentifier) => {
 };
 /** Register a concrete identifier class under its polymorphic _type (the *_TYPE_MAP role). */
 export declare function registerType(klass: IdentifierStatic): void;
+export declare function resolveType(type: string): IdentifierStatic | undefined;
 export declare abstract class BaseIdentifier {
     static polymorphicName: string;
     /** The human renderer body — the one method every flavor writes. */

package/dist/model/identifier.js

@@ -25,7 +25,7 @@ const TYPE_REGISTRY = new Map();
 export function registerType(klass) {
     TYPE_REGISTRY.set(klass.polymorphicName, klass);
 }
-function resolveType(type) {
+export function resolveType(type) {
     return TYPE_REGISTRY.get(type);
 }
 function isScalarType(t) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pubid/pubid",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "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",