@pubid/pubid 0.1.36 → 0.1.38

package/dist/flavors/bipm/index.js

@@ -130,15 +130,30 @@ function buildRules() {
         .or(str("SI Brochure"))
         .or(str("Brochure sur le SI"))
         .then(space, str("sur le SI").then(space).maybe(), rules["edition"], 
-    // The version and the language code are optional (the guide's
-    // language-independent form, "SI Brochure 9e (2019, E)").
-    space.then(rules["version"]).maybe(), space, str("("), rules["years"], str(", ").then(lang()).maybe(), str(")"))
+    // The version and the trailing parenthetical are optional (the
+    // guide's language-independent form "SI Brochure 9e (2019, E)";
+    // the year-less editions "BIPM SI Brochure 9e" and "… (E)" must
+    // re-parse as canonically rendered, pubid#694 ruling R1).
+    space.then(rules["version"]).maybe(), space
+        .then(str("(")
+        .then(rules["years"], str(", ").then(lang()).maybe(), str(")"))
+        .or(str("(").then(lang(), str(")"))))
+        .maybe())
         .as("si_brochure"));
     // The corpus-cited ordinal-edition spelling ("SI Brochure 9th edition
     // (2019)") normalizes the English ordinal onto the canonical "9e".
     rule("si_brochure_ordinal_edition", () => str("SI Brochure")
         .then(space, digits.then(ordinal()).as("ordinal_edition"), space, str("edition"), space.then(rules["year_paren"]).maybe())
         .as("si_brochure_ordinal_edition"));
+    // The unmerged si-brochure-id proposal's bare-number edition spellings
+    // ("SI Brochure 9", "SI Brochure 9 (E)", "SI Brochure 9 (2024) (F)"):
+    // the edition carries no trailing "e", and the year and the language
+    // may each sit in their own parentheses (pubid#694 ruling R1). A
+    // parse-in alias of the canonical "9e" edition — the builder appends
+    // the "e" the proposal drops.
+    rule("si_brochure_bare_edition", () => str("SI Brochure")
+        .then(space, digits.as("bare_edition"), space.then(str("("), rules["years"], str(")")).maybe(), space.then(str("("), lang(), str(")")).maybe())
+        .as("si_brochure_bare_edition"));
     rule("brochure_variant", () => str("Appendix")
         .then(space, digits)
         .or(str("Concise"), str("FAQ"))
@@ -167,7 +182,7 @@ function buildRules() {
         .or(guideBody())
         .as("guide"));
     rule("group_leading", () => rules["meeting_en"].or(rules["meeting_fr"], rules["committee_short"], rules["committee_long_en"], rules["committee_group_fr"], rules["committee_bare"]));
-    rule("identifier", () => rules["metrologia"].or(rules["si_brochure"], rules["si_brochure_variant"], rules["si_brochure_section"], rules["si_brochure_ordinal_edition"], rules["mep"], rules["guide"], rules["committee_long_fr"], rules["committee_prefixed"], rules["group_leading"]));
+    rule("identifier", () => rules["metrologia"].or(rules["si_brochure"], rules["si_brochure_variant"], rules["si_brochure_section"], rules["si_brochure_ordinal_edition"], rules["si_brochure_bare_edition"], rules["mep"], rules["guide"], rules["committee_long_fr"], rules["committee_prefixed"], rules["group_leading"]));
     rule("root", () => rules["identifier"]);
     return rules;
 }
@@ -246,22 +261,29 @@ class BipmUrnGenerator extends BaseUrnGenerator {
     generate() {
         const id = this.identifier;
         if (id instanceof BipmCommitteeDocument) {
+            // The guide-of-record faces (pubid#694, ruling R2): the v1 version
+            // segment leads every family and the type segment spells the English
+            // type name lowercased ("decision"), never the REC/RES/DECN code.
+            // type_code is nil for the bare MRA form -> empty type segment.
+            const typeSegment = id.type_code === undefined
+                ? ""
+                : (TYPE_NAME_EN[id.type_code] ?? id.type_code).toLowerCase();
             const parts = [
-                "urn", "bipm", id.group?.toLowerCase() ?? "",
-                id.type_code?.toLowerCase() ?? "", committeeNumberSegment(id),
+                "urn", "bipm", "v1", id.group?.toLowerCase() ?? "",
+                typeSegment, committeeNumberSegment(id),
             ];
             if (id.year !== undefined)
                 parts.push(String(id.year));
             return parts.join(":");
         }
         if (id instanceof BipmMeeting) {
-            const parts = ["urn", "bipm", id.group?.toLowerCase() ?? "", "meeting", id.number ?? ""];
+            const parts = ["urn", "bipm", "v1", id.group?.toLowerCase() ?? "", "meeting", id.number ?? ""];
             if (id.year !== undefined)
                 parts.push(String(id.year));
             return parts.join(":");
         }
         if (id instanceof BipmMetrologiaArticle) {
-            const parts = ["urn", "bipm", "metrologia", String(id.volume())];
+            const parts = ["urn", "bipm", "v1", "metrologia", String(id.volume())];
             if (id.issue !== undefined)
                 parts.push(id.issue);
             if (id.article !== undefined)
@@ -269,9 +291,14 @@ class BipmUrnGenerator extends BaseUrnGenerator {
             return parts.join(":");
         }
         if (id instanceof BipmSiBrochure) {
+            // The guide's edition-number carries no "e" ("9e" emits "9"); the
+            // version drops its "v"; the year is the latest of the years range;
+            // the language segment is dropped entirely.
             return [
-                "urn", "bipm", "si-brochure", id.language?.toLowerCase() ?? "",
-                id.edition ?? "", id.version ?? "", id.years ?? "",
+                "urn", "bipm", "v1", "bipm", "si-brochure",
+                (id.edition ?? "").replace(/e$/i, ""),
+                (id.version ?? "").replace(/^v/i, ""),
+                (id.years ?? "").split("/").pop() ?? "",
             ].join(":");
         }
         throw new ParseFailed(`Cannot build URN for BIPM identifier: ${id.constructor.polymorphicName}`, 0);
@@ -284,6 +311,14 @@ class BipmCommitteeDocument extends BipmIdentifier {
         if (this.form === "long") {
             if (this.language === "F") {
                 const name = TYPE_NAME_FR[this.type_code ?? ""] ?? "";
+                // The guide's body-prefixed French pattern ("Décision CIPM/111-10
+                // (2022)") is the canonical long face (pubid#694, ruling R3): the
+                // group qualifies the resource-specific id with a slash. A
+                // number-less document keeps the connective spelling the guide's
+                // general French pattern uses ("Statement de la CGPM (1889)").
+                if (this.number !== undefined) {
+                    return `${name} ${this.group}/${this.number}${this.yearSegment()}`;
+                }
                 return `${name}${this.numberSegment()} ${frenchConnective(this.group ?? "")} ${this.group}${this.yearSegment()}`;
             }
             const name = TYPE_NAME_EN[this.type_code ?? ""] ?? "";
@@ -343,10 +378,18 @@ class BipmSiBrochure extends BipmIdentifier {
             const part = this.part === undefined ? "" : ` Part ${this.part}`;
             return `BIPM SI Brochure${part}`;
         }
+        // The parens carry the year, the language or both, and stay off
+        // entirely when the reference names neither ("SI Brochure 9e", the
+        // bare edition without a year — pubid#694's renderer fix).
         const phrase = this.language === "F" ? "sur le SI " : "";
         const lang = this.language === undefined ? "" : `, ${this.language}`;
         const version = this.version === undefined ? "" : ` ${this.version}`;
-        return `BIPM SI Brochure ${phrase}${this.edition}${version} (${this.years}${lang})`;
+        const tail = this.years !== undefined ? `${this.years}${lang}` : (this.language ?? "");
+        let result = `BIPM SI Brochure ${phrase}${this.edition}${version}`;
+        if (this.years !== undefined || this.language !== undefined) {
+            result += ` (${tail})`;
+        }
+        return result;
     }
 }
 registerType(BipmSiBrochure);
@@ -446,6 +489,23 @@ class BipmBuilder {
                 language: normalizeLanguage(s(n["language"])),
             });
         }
+        if (tree["si_brochure_bare_edition"] !== undefined) {
+            // The proposal drops the trailing "e"; the builder appends it back
+            // so the bare-number spellings are parse-in aliases of the canonical
+            // "9e" edition (pubid#694 ruling R1). The year and the language sit
+            // in separate parentheses; an absent year stays undefined (a partial
+            // reference, like "SI Brochure 9th edition" without a year).
+            const n = node("si_brochure_bare_edition");
+            const edition = `${s(n["bare_edition"])}e`;
+            const year = s(n["year"]);
+            const language = normalizeLanguage(s(n["language"]));
+            return new BipmSiBrochure({
+                number: edition,
+                edition,
+                ...(year !== undefined ? { years: year } : {}),
+                ...(language !== undefined ? { language } : {}),
+            });
+        }
         if (tree["mep"] !== undefined) {
             const n = node("mep");
             const mepCode = s(n["mep_code"]);
@@ -500,40 +560,84 @@ export function bipmGrammarImplementation() {
         // 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.
+        //
+        // Two URN generations parse (pubid#694): the canonical face leads with
+        // the guide's `v1` version segment; the pre-adoption face this flavor
+        // emitted for years stays parseable as a documented parse-in alias of
+        // the same identity. The EMITTER is the new shape; an alias never
+        // renders back as itself, it rebuilds the identifier whose toUrn is
+        // the v1 face.
         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") {
+            const canonical = parts[0] === "v1";
+            const p = canonical ? parts.slice(1) : parts;
+            if (p[0] === "metrologia") {
                 return new BipmMetrologiaArticle({
-                    number: presence(parts[1]),
-                    issue: parts[2],
-                    article: parts[3],
+                    number: presence(p[1]),
+                    issue: p[2],
+                    article: p[3],
+                });
+            }
+            if (canonical && p[0] === "bipm") {
+                // `bipm:si-brochure:<edition-number>:<version-number>:<year>` —
+                // the guide strips the "e" off the edition and the "v" off the
+                // version and drops the language segment, so they are restored
+                // here; the year stores back verbatim (idempotent emission).
+                const edition = presence(p[2]);
+                const version = presence(p[3]);
+                return new BipmSiBrochure({
+                    number: edition ? `${edition}e` : undefined,
+                    edition: edition ? `${edition}e` : undefined,
+                    version: version ? `v${version}` : undefined,
+                    years: presence(p[4]),
                 });
             }
-            if (parts[0] === "si-brochure") {
+            if (p[0] === "si-brochure") {
+                // Legacy face: `si-brochure:<lang>:<edition>:<version>:<years>`.
                 return new BipmSiBrochure({
-                    number: presence(parts[2]),
-                    language: (parts[1] ?? "").toUpperCase(),
-                    edition: parts[2],
-                    version: parts[3],
-                    years: parts[4],
+                    number: presence(p[2]),
+                    language: (p[1] ?? "").toUpperCase(),
+                    edition: p[2],
+                    version: p[3],
+                    years: p[4],
                 });
             }
-            const group = (parts[0] ?? "").toUpperCase();
-            if (parts[1] === "meeting") {
+            const group = (p[0] ?? "").toUpperCase();
+            if (p[1] === "meeting") {
                 return new BipmMeeting({
                     group,
-                    number: parts[2] ?? "",
-                    year: parts[3] ? Number(parts[3]) : undefined,
+                    number: p[2] ?? "",
+                    year: p[3] ? Number(p[3]) : undefined,
                 });
             }
+            // The legacy face carried the lowercase type abbreviation ("res");
+            // the v1 face carries the lowercase English type name ("resolution").
+            // Both resolve through TYPE_WORD_TO_CODE, so an empty segment (the
+            // bare MRA form) stays a nil type_code on either face.
+            const segment = presence(p[1]);
+            const word = segment === undefined
+                ? undefined
+                : canonical
+                    ? segment.charAt(0).toUpperCase() + segment.slice(1)
+                    : segment.toUpperCase();
+            // Inverse of committeeNumberSegment: split the folded
+            // "-a{appendix}[.{annex}]" tail back out of the identifier segment.
+            // A bare number is digits and dashes only, so the letter-prefixed
+            // tail is unambiguous.
+            const raw = p[2] ?? "";
+            const folded = /^(.+?)-a(\d+)(?:\.(\d+))?$/.exec(raw);
+            const number = folded ? folded[1] : raw;
             return new BipmCommitteeDocument({
                 group,
-                type_code: presence(parts[1])?.toUpperCase(),
-                number: presence(parts[2]),
-                year: parts[3] ? Number(parts[3]) : undefined,
+                type_code: word === undefined ? undefined : TYPE_WORD_TO_CODE[word],
+                number: presence(number),
+                year: p[3] ? Number(p[3]) : undefined,
+                ...(folded
+                    ? { appendix: folded[2], ...(folded[3] !== undefined ? { annex: folded[3] } : {}) }
+                    : {}),
             });
         },
         parse(input) {

package/dist/flavors/ecma/index.js

@@ -106,11 +106,45 @@ class EcmaBuilder extends BaseBuilder {
         return value;
     }
 }
+/**
+ * The human edition spellings that alias the glued " ed<N>" token
+ * (pubid#698; ruby Ecma::Parser.normalize_input), in rewrite order.
+ * Each rule rewrites INTO the exact canonical face, so the parse (and
+ * therefore the render, the URN and the index key) is the one " ed<N>"
+ * already produces, and a canonical face passes through
+ * byte-identically.
+ *
+ *   ECMA-262 Edition 5.1   the document cover's own form
+ *   ECMA-262 ed. 5.1       dotted, spaced
+ *   ECMA-262 ed 5.1        spaced, undotted
+ *   ECMA-262 ed.5.1        dotted, unspaced
+ *   ECMA 262 5.1           bare trailing edition
+ *
+ * " ed5.1" (no separator) is the grammar's own face and is left alone;
+ * a " vol<N>" number is never rewritten — the bare-trailing rule fires
+ * only behind a document number's own digit ("ECMA 262 5.1"), so the
+ * space-separator form itself ("ECMA 6") keeps its number and the
+ * grammar's ed-then-vol order is untouched.
+ */
+const EDITION_ALIASES = [
+    // "Edition <N>" starts mid-word, so the replacement carries no space
+    // of its own — the space before it is kept as-is.
+    [/\bedition[.\s]*(\d+(?:\.\d+)?)\b/gi, "ed$1"],
+    // "ed. <N>" / "ed <N>" / "ed.<N>": same mid-word shape. The glued
+    // "ed5.1" has no separator after "ed" and cannot match [.\s]+.
+    [/\bed[.\s]+(\d+(?:\.\d+)?)\b/g, "ed$1"],
+    // Bare trailing edition: fires only when a document number is already
+    // present (a digit directly before the space — "ECMA 262 5.1"). A
+    // glued "vol2" has no space, and a spaced "vol 2" has no digit before
+    // the space, so a volume number is never rewritten.
+    [/(\d) (\d+(?:\.\d+)?)$/, "$1 ed$2"],
+];
 export function ecmaGrammarImplementation() {
     const builder = new EcmaBuilder();
     return {
         parse(input) {
-            const tree = parseGrammar(ecmaGrammar, input);
+            const normalized = EDITION_ALIASES.reduce((acc, [pattern, replacement]) => acc.replace(pattern, replacement), input);
+            const tree = parseGrammar(ecmaGrammar, normalized);
             if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
                 throw new ParseFailed("ECMA: unexpected parse tree", 0);
             }

package/dist/flavors/iec/grammar.js

@@ -86,8 +86,9 @@ function buildRules() {
     // --- supplements ---
     const SUPP_ABBRS = [
         "PRF Amd", "PWI Amd", "NP Amd", "ANW Amd", "WD Amd",
-        "PRF Cor", "PWI Cor", "NP Cor", "ANW Cor", "WD Cor", "CDCor", "WDCor",
-        "CDAM", "DAM", "FDAM", "DCOR", "FDCOR", "AMD", "Amd", "COR", "Cor", "ISH", "Ish",
+        "PRF Cor", "PWI Cor", "NP Cor", "ANW Cor", "WD Cor", "CDCor", "CDCOR", "WDCor",
+        "CDAM", "DAM", "FDAM", "PDAM", "FPDAM", "DCOR", "FDCOR", "AMD", "Amd", "COR", "Cor",
+        "CDISH", "DISH", "ISH", "Ish",
     ];
     rule("supplement_type_with_stage", () => SUPP_ABBRS.reduce((acc, a) => acc.or(str(a)), str(SUPP_ABBRS[0]))
         .or(str("FRAG"))
@@ -155,6 +156,15 @@ function buildRules() {
         .then(str("/"), rules["supplement_type_with_stage"])
         .then(spaceQ, rules["second_part"], rules["third_part"]));
     rule("supplement_identifier_no_third", () => rules["identifier_copublishers_no_third"].as("base")
+        // The [language] slot between the base designation and the
+        // supplement token: the renderer prints the BASE document's
+        // languages right after its date
+        // ("ISO/IEC 19772:2009(en)/DAM1:2019" — the rendered twin of the
+        // stored "ISO/IEC 19772:2009/DAM 1:2019(E)" input), and without
+        // the slot the canonical face could not re-parse. The capture
+        // lands on the base (the builder's supplement branch routes it
+        // there, like the supplement's own third_part language).
+        .then(rules["language"].maybe())
         .then(str("/"), rules["supplement_type_with_stage"])
         .then(spaceQ, rules["second_part"]));
     rule("supplement_identifier", () => rules["supplement_identifier_no_third"].then(rules["third_part"]));
@@ -164,9 +174,36 @@ function buildRules() {
     rule("standalone_supplement", () => rules["prefix_with_copublishers"]
         .then(str("/"), rules["supplement_type_with_stage"])
         .then(space, rules["second_part"], rules["third_part"]));
+    // --- the legacy DAM-family prefix face (the JTC1 ballot spelling;
+    // decode-to-modern, owner ruling 2026-11-12) ---
+    // The stage token precedes the base designation — "IEC/FDAM 60038-1",
+    // "ISO/IEC PDAM 12207", "ISO/IEC PDAM 2 10646:2012",
+    // "ISO/IEC FPDAM 9075/1", "ISO/IEC FDAM 1 14496-12:2004". A number
+    // between the token and the designation is the SUPPLEMENT number; the
+    // designation is the base's and is kept whole (unnumbered
+    // DAM/PDAM/FDAM/FPDAM means Amendment 1, and the old slash-part
+    // spelling "9075/1" carries the base's part). The date rides with the
+    // designation — old notation prints the base's year, and the draft
+    // supplement carries none of its own. Longest tokens first: FPDAM
+    // before PDAM, FDAM before DAM. The slash-part alternative precedes
+    // the dash-part one: the designation body also matches a bare number,
+    // so a slash-part input must be claimed first or the "/1" would
+    // dangle unclaimed.
+    rule("legacy_dam_token", () => str("FPDAM").or(str("PDAM"), str("FDAM"), str("DAM")).as("legacy_stage"));
+    // The copublisher captures as its own top-level scalar (the wasm
+    // binder scatters array bindings over the sibling list when a bare
+    // copublisher node rides a flat shape — the parg uses the same
+    // legacy_copublisher_item rule for that).
+    rule("legacy_copublisher_item", () => str("/").then(spaceQ, ORGS.reduce((acc, o) => acc.or(str(o)), str(ORGS[0])).as("legacy_copublisher")));
+    rule("legacy_base_designation", () => match("[0-9]").repeat(1, 6).as("legacy_base_number")
+        .then(str("/"), match("[0-9]").repeat(1, Infinity).as("legacy_base_part"))
+        .or(rules["number_with_part"].as("legacy_base_number_with_part")));
+    rule("legacy_supplement", () => rules["prefix_sole_publisher"]
+        .then(spaceQ, rules["legacy_copublisher_item"].maybe(), spaceQ, str("/").maybe(), rules["legacy_dam_token"], space, match("[0-9]").repeat(1, Infinity).as("legacy_supplement_number").then(space).maybe(), rules["legacy_base_designation"], (spaceQ.then(rules["date"])).maybe(), rules["third_part"]));
     rule("identifier", () => rules["working_programme"]
         .or(rules["technical_group"])
         .or(rules["working_document"])
+        .or(rules["legacy_supplement"])
         .or(rules["sheet_supplement_identifier"])
         .or(rules["sheet_identifier"])
         .or(rules["supplement_supplement_identifier"])

package/dist/flavors/iec/index.js

@@ -62,6 +62,20 @@ class IecBuilder {
             delete tree["vap_suffix"];
             tree["base"]["vap_suffix"] = vapSuffix;
         }
+        // The third_part language rides the BASE document on every
+        // attached-supplement layer: the ruby grammar binds the layers'
+        // language unprefixed, the supplement field set keeps none
+        // (SUPP_KEYS), and the wire carries base.languages — the ruby
+        // render prints it inside the base portion
+        // ("ISO/IEC 19772:2009(en)/DAM1:2019"). Push it down before
+        // dispatching; the recursion re-applies it until it reaches the
+        // base. A standalone supplement (no base tree) keeps its own
+        // languages, like ruby's standalone slice.
+        const languages = tree["languages"];
+        if (languages !== undefined && isObj(tree["base"])) {
+            delete tree["languages"];
+            tree["base"]["languages"] = languages;
+        }
         // --- working programme / working document ---
         if (tree["wp_stage"] !== undefined)
             return this.buildWorkingProgramme(tree);
@@ -71,6 +85,10 @@ class IecBuilder {
         if (tree["technical_committee"] !== undefined) {
             throw new ParseFailed("IEC: technical groups are not corpus-covered", 0);
         }
+        // --- the legacy DAM-family prefix face (decode-to-modern) ---
+        if (tree["legacy_stage"] !== undefined) {
+            return this.buildLegacySupplement(tree);
+        }
         // --- fragment of an amendment/corrigendum (third_part notation) ---
         if (tree["fragment_type"] !== undefined && tree["base"] !== undefined) {
             return this.buildFragment(tree);
@@ -153,6 +171,41 @@ class IecBuilder {
             kind: kind,
             attrs,
         };
+        // The ensure_base decode (ruby SupplementIdentifier#ensure_base;
+        // the 2026-11-12 owner ruling reversing #693): a standalone draft
+        // face whose designation is designation-shaped ("IEC/DCOR 60038-1",
+        // "IEC CDISH 60050-191") moves the designation WHOLE onto a
+        // concrete InternationalStandard base — number, part, subpart and
+        // the date (old notation prints the base's year) — while the
+        // supplement keeps a number of its own, defaulting to 1 (the
+        // no-number rule: an unnumbered DCOR/DISH/CDISH means
+        // Corrigendum/Interpretation-Sheet 1). The concrete base is what
+        // makes the decode hash-match (and equal) the modern on-base parse
+        // of the same document. A supplement with no part (a true
+        // standalone like "IEC/AMD 1:2017") keeps its own number below.
+        if ((kind === "amd" || kind === "cor" || kind === "ish") &&
+            tree["base"] === undefined &&
+            attrs["part"] !== undefined) {
+            const baseAttrs = {};
+            for (const key of ["publisher", "copublishers", "number", "part", "subpart", "date"]) {
+                if (attrs[key] !== undefined)
+                    baseAttrs[key] = attrs[key];
+            }
+            const base = new IEC_CLASSES.KIND_CLASSES["is"](baseAttrs);
+            const suppAttrs = { base, number: "1" };
+            // Supplements copy the delegated publisher/copublishers level
+            // (ruby reads them through the base; the stored wire copies the
+            // non-default level).
+            if (attrs["publisher"] !== undefined && attrs["publisher"] !== "IEC") {
+                suppAttrs["publisher"] = attrs["publisher"];
+            }
+            if (Array.isArray(attrs["copublishers"]) && attrs["copublishers"].length > 0) {
+                suppAttrs["copublishers"] = attrs["copublishers"];
+            }
+            const supplement = this.construct({ kind: kind, attrs: suppAttrs, typedStage }, suppAttrs);
+            supplement["base"] = base;
+            return supplement;
+        }
         // Consolidated supplements (+AMD…+AMD…)
         const consolidated = tree["consolidated_supplements"];
         let identifier = this.construct(parsed, attrs);
@@ -219,6 +272,63 @@ class IecBuilder {
             ...(edition !== undefined ? { edition } : {}),
         });
     }
+    /**
+     * The legacy DAM-family prefix face (IEC/FDAM 60038-1, ISO/IEC PDAM
+     * 2 10646:2012, ISO/IEC FPDAM 9075/1): the JTC1 ballot spelling puts
+     * the stage token before the base designation. Decode onto the
+     * modern identity (owner ruling 2026-11-12): the designation is the
+     * BASE's, kept whole — the old slash-part spelling "9075/1" is base
+     * 9075 part 1 — and the supplement's number is the captured N,
+     * defaulting to 1 (the no-number rule). The date rides with the
+     * designation (old notation prints the base's year); a draft
+     * supplement carries none of its own. The base builds through the
+     * ordinary single-document path, so it is the same
+     * InternationalStandard the modern on-base parse holds and
+     * parse(legacy) == parse(modern).
+     */
+    buildLegacySupplement(tree) {
+        const baseTree = {};
+        if (tree["publisher"] !== undefined)
+            baseTree["publisher"] = tree["publisher"];
+        if (tree["legacy_copublisher"] !== undefined) {
+            baseTree["copublishers"] = [s(tree["legacy_copublisher"])];
+        }
+        if (tree["legacy_base_number"] !== undefined) {
+            // The slash-part designation ("9075/1") captured number and part
+            // separately; they go on straight as the plain strings the
+            // retyped attributes are.
+            baseTree["number_with_part"] = {
+                number: s(tree["legacy_base_number"]),
+                ...(s(tree["legacy_base_part"]) !== undefined ? { part: s(tree["legacy_base_part"]) } : {}),
+            };
+        }
+        else if (tree["legacy_base_number_with_part"] !== undefined) {
+            const designation = tree["legacy_base_number_with_part"];
+            baseTree["number_with_part"] = isObj(designation)
+                ? flatten(designation)["number_with_part"]
+                : designation;
+        }
+        if (tree["date"] !== undefined)
+            baseTree["date"] = tree["date"];
+        if (tree["undated_marker"] !== undefined)
+            baseTree["undated_marker"] = tree["undated_marker"];
+        if (tree["edition"] !== undefined)
+            baseTree["edition"] = tree["edition"];
+        if (tree["languages"] !== undefined)
+            baseTree["languages"] = tree["languages"];
+        // The wrap: one amendment/corrigendum layer over the whole base;
+        // third_part's fragment notation rides the outermost layer.
+        const suppTree = {
+            base: baseTree,
+            type_with_stage: s(tree["legacy_stage"]),
+            number_with_part: { number: s(tree["legacy_supplement_number"]) ?? "1" },
+        };
+        if (tree["fragment_type"] !== undefined) {
+            suppTree["fragment_type"] = tree["fragment_type"];
+            suppTree["fragment_number"] = tree["fragment_number"];
+        }
+        return this.buildInner(suppTree);
+    }
     buildSupplement(tree) {
         const base = this.buildInner(tree["base"]);
         const stageAbbr = s(tree["type_with_stage"]) ?? "";

package/dist/flavors/iec/model.js

@@ -44,8 +44,20 @@ export const TYPED_STAGES = [
     TS("ndts", "ndts", "ts", "NDTS"),
     TS("dpas", "dpas", "pas", "DPAS"),
     TS("cdpas", "cdpas", "pas", "CDPAS"),
-    TS("dam", "dam", "amd", "DAM"),
-    TS("fdam", "fdam", "amd", "FDAM"),
+    // The DAM family's ballot stages carry the CIRCULATION slots as the
+    // lead harmonized code (30.20/50.20), not ISO's 30.00/50.00 — CDAM/
+    // FDAM keep those (type, leading code) URN keys (gem Amendment
+    // registry; the codes are the per-typed-stage keys the wire
+    // serializes: pdam, damd, fdamd, fpdam).
+    TS("pdam", "cd", "amd", "PDAM", "30.20"),
+    TS("damd", "damd", "amd", "DAM", "40.00"),
+    TS("fdamd", "fdamd", "amd", "FDAM", "50.00", ["FDAM", "PRF Amd"]),
+    TS("fpdam", "fdamd", "amd", "FPDAM", "50.20"),
+    // "CDCOR" is the all-caps spelling the attached-supplement renderer
+    // emits (abbr.first upcase) when a legacy prefix face decodes onto a
+    // CDCor draft; appended as a token so the canonical render re-parses
+    // (spelling-only: abbr stays "CDCor").
+    TS("cdcor", "cd", "cor", "CDCor", "30.00", ["CDCor", "CDCOR"]),
     TS("dcor", "dcor", "cor", "DCOR"),
     TS("fdcor", "fdcor", "cor", "FDCOR"),
     TS("cdish", "cdish", "ish", "CDISH"),
@@ -311,6 +323,10 @@ function iecSupplementClass(kind) {
         static attributes = extendAttributes(BaseIdentifier, {
             base: { type: IecIdentifier },
             number: { type: "string" },
+            // The draft stage rides the wire as the typed stage's code
+            // ("stage: fdamd") — the single classes declare the same attr
+            // (SINGLE_ATTRS.stage); construct sets it on the parse path.
+            stage: { type: "string" },
             synthetic_base: { type: "boolean", default: false },
         });
         static mappings = keyValue({ wire: "number", to: "number" }, { wire: "year", to: "date", toWire: (m) => m["date"]?.year, fromWire: yearFromWire }, { wire: "month", to: "date", toWire: (m) => m["date"]?.month, fromWire: () => undefined }, { wire: "day", to: "date", toWire: (m) => m["date"]?.day, fromWire: () => undefined }, { wire: "edition", to: "edition" }, {
@@ -326,7 +342,11 @@ function iecSupplementClass(kind) {
                 return list !== undefined && list.length > 0 ? list : undefined;
             },
             fromWire: (h) => (Array.isArray(h["copublishers"]) ? h["copublishers"].map(String) : undefined),
-        }, { wire: "base", to: "base" });
+        }, 
+        // The draft stage rides the wire as the typed stage's code
+        // ("stage: fdamd"); the single classes map the same key (ruby
+        // serializes typed_stage.code and restores it in from_hash).
+        { wire: "stage", to: "stage" }, { wire: "base", to: "base" });
         render() {
             const base = this.base;
             if (base === undefined || this.synthetic_base === true) {
@@ -340,7 +360,12 @@ function iecSupplementClass(kind) {
                 return result;
             }
             let result = base.render();
-            result += `/${abbr}${this.number ?? ""}`;
+            // The attached-supplement renderer prints the typed stage's own
+            // abbreviation, upcased (ruby renderer.rb: abbr.first.upcase) —
+            // a published Amendment renders "/AMD1", a draft stage its own
+            // token ("/FDAM1", "/DCOR1", "/CDCOR1" from the "CDCor" entry's
+            // spelling-only upcase).
+            result += `/${(this.typedStage?.abbr ?? abbr).toUpperCase()}${this.number ?? ""}`;
             if (this.date !== undefined)
                 result += `:${this.date.render()}`;
             if (this.edition !== undefined)