@pubid/pubid 0.1.4 → 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/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/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/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;