@pubid/pubid 0.1.12 → 0.1.14

package/dist/flavors/ieee/index.js

@@ -284,6 +284,14 @@ class IeeeBuilder {
     determineIdentifierClass(attributes) {
         if (attributes["publisher"] === "AIEE")
             return AieeClass;
+        // A stage-bearing row is a joint development whatever its type
+        // code: the stage is the printed identity ("IEEE P15026.2/FDIS",
+        // pubid#203) and only the joint model carries iso_stage and the D=
+        // designator (the reference's chooser).
+        if (attributes["iso_stage"] !== undefined ||
+            (attributes["ieee_draft"] ?? "").startsWith("D=")) {
+            return JointDevelopmentClass;
+        }
         const typeCode = attributes["type"];
         if (typeCode === "P")
             return ProjectDraftIdentifierClass;
@@ -438,6 +446,33 @@ class IeeeBuilder {
         if (day !== undefined)
             attributes["day"] = day;
         this.handleDraft(parsed, attributes);
+        this.foldDraftDateTail(attributes);
+        // The bare-IEEE fdraft clause (pubid#203): a slash-led stage word
+        // after the code ("IEEE P15026.2/FDIS, August 2010") rides the D=
+        // designator with the IEEE date convention ("D=FDIS-201008"); the
+        // ISO face is not elected (the reference's fdraft rule).
+        const fdraft = parsed["fdraft"];
+        if (fdraft !== undefined && typeof fdraft === "object" && !Array.isArray(fdraft)) {
+            const fdStage = extractValue(fdraft["fdraft_stage"]);
+            if (fdStage !== undefined) {
+                const fdYear = extractValue(fdraft["year"]);
+                const fdMonth = extractValue(fdraft["month"]);
+                let date = "";
+                if (fdYear !== undefined) {
+                    date = `-${fdYear}`;
+                    const monthNum = fdMonth !== undefined
+                        ? DRAFT_MONTH_NAMES[String(fdMonth).replace(/\.$/, "")]
+                        : undefined;
+                    if (monthNum !== undefined)
+                        date += monthNum.padStart(2, "0");
+                }
+                attributes["publishers"] ??= [attributes["publisher"] ?? "IEEE"];
+                attributes["ieee_draft"] = `D=${fdStage}${date}`;
+                const fdRecord = locateStage(fdStage);
+                if (fdRecord !== undefined)
+                    attributes["typed_stage"] = new IeeeTypedStage(fdRecord);
+            }
+        }
         this.applyDefaultDraftVersion(attributes, typeValue);
         this.handleKeyedHash(parsed, "corrigendum", attributes, "cor_number", "cor_year");
         this.handleKeyedHash(parsed, "amendment", attributes, "amd_number", "amd_year");
@@ -533,23 +568,39 @@ class IeeeBuilder {
             if (draftData["draft_version"] !== undefined) {
                 const dv = draftData["draft_version"];
                 version = Array.isArray(dv) ? dv.map((v) => extractValue(v) ?? "").join("") : extractValue(dv);
+                // The reference's designator normalization (gem#552): a leading
+                // hyphen drops, and a three-digit-plus zero-padded designator
+                // sheds its zero ("/013.0" -> "13.0" — the 2026-10-19 ruling;
+                // the strip is scoped to the dotted designator class — "D043"/
+                // "D09"/"D0.16" keep their conventional widths).
                 if (version !== undefined)
-                    version = version.replace(/^-/, "");
+                    version = version.replace(/^-/, "").replace(/^0(?=\d+\.\d)/, "");
             }
             revision = extractValue(draftData["revision"]);
             isoStage = extractValue(draftData["draft_iso_stage"]);
             isoIteration = extractValue(draftData["draft_iso_iteration"]);
             // FDIS/CDV/… are ISO/IEC stage tokens, not draft ordinals (C1
-            // ruling, testsuite#2). "/DDIS" and "/DFDIS" are hallucinated
+            // ruling, testsuite#2). "/DDIS" and "/DFCD" are hallucinated
             // concatenations — the designator D does not merge onto a stage
             // word. The draft of a stage rides the iso_stage slot, which
             // Draft#to_s renders as the D= designator face ("…/D=DIS-2020").
-            if (version !== undefined && /^(FDIS|FCD|CDV|DIS|CD|WD|PWI|NP)$/.test(version)) {
-                isoStage = version;
-                version = undefined;
-            }
+            // The glued month-name date ("-June2010", the 2026-10-19 FCD
+            // ruling) rides the designator's date slot with the month numeric.
             month = extractValue(draftData["month"]);
             year = extractValue(draftData["year"]);
+            if (version !== undefined) {
+                // The stage iteration rides glued onto the word ("DIS2" — the
+                // lossless face, pubid#477; the 2026-10-19 DIS2 ruling).
+                const stageDate = /^(FDIS|FCD|CDV|DIS|CD|WD|PWI|NP)(\d+)?(?:-([A-Za-z]+)(\d{4}))?$/.exec(version);
+                if (stageDate !== null) {
+                    isoStage = stageDate[1] + (stageDate[2] ?? "");
+                    if (stageDate[3] !== undefined) {
+                        month = DRAFT_MONTH_NAMES[stageDate[3]] !== undefined ? stageDate[3] : month;
+                        year = stageDate[4];
+                    }
+                    version = undefined;
+                }
+            }
             // The apostrophe-year catalogue convention ("P1484.20.1/D7,
             // May 07"): the 2-digit year expands with the <30 pivot so the
             // hash carries an unambiguous year (the reference's builder).
@@ -598,6 +649,42 @@ class IeeeBuilder {
             attributes["draft"] = draftObj.render();
         }
     }
+    // A draft-date that routed to the identity slots (the grammar's
+    // month/year captures beside a bare draft ordinal) folds onto the
+    // draft designator: a REV-carrier embeds it numerically
+    // ("P1310Rev3/D2, February 2011" renders "D2-2011-02" — the
+    // reference's builder), a plain draft keeps the printed face routed
+    // through the draft's own parse so the month canonicalizes to the
+    // crawl abbreviation ("D08, September 2018" renders "D08, Sept,
+    // 2018"; a space-faced input stays space-faced).
+    foldDraftDateTail(attributes) {
+        const month = attributes["month"];
+        const year = attributes["year"];
+        const draft = attributes["draft"];
+        if (typeof month !== "string" || typeof year !== "string" ||
+            typeof draft !== "string" || !/^\/D[^ =,]+$/.test(draft)) {
+            return;
+        }
+        const draftNum = draft.slice(2);
+        if (attributes["revision"] !== undefined || attributes["rev_bare"] === true) {
+            const monthNum = DRAFT_MONTH_NAMES[String(month).replace(/\.$/, "")];
+            if (monthNum === undefined)
+                return;
+            attributes["draft"] =
+                new IeeeDraft({ version: `${draftNum}-${year}-${monthNum.padStart(2, "0")}` }).render();
+        }
+        else {
+            const escaped = month.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const commaFace = this.originalInput !== "" &&
+                new RegExp(`,\\s+${escaped}`, "i").test(this.originalInput);
+            const reparsed = IeeeDraft.parse(`${draftNum}${commaFace ? ", " : " "}${month} ${year}`);
+            if (reparsed === undefined)
+                return;
+            attributes["draft"] = reparsed.render();
+        }
+        delete attributes["month"];
+        delete attributes["year"];
+    }
     applyDefaultDraftVersion(attributes, typeValue) {
         if (attributes["draft"] !== undefined)
             return;
@@ -885,6 +972,18 @@ class IeeeBuilder {
             if (attributes["month"] === undefined)
                 attributes["month"] = extractValue(parsed["draft_month"]);
         }
+        // A status word ("Unapproved") marks the draft (pubid#318).
+        const jointDraftStatus = extractValue(parsed["draft_status"]);
+        if (jointDraftStatus !== undefined)
+            attributes["draft_status"] = jointDraftStatus;
+        // A dash_year tail ("/D-3-2007") is the identity year when the
+        // slots are otherwise empty — the ISO face prints it colon-joined
+        // ("ISO/IEC/IEEE FDIS P15288:2007", the reference's 9258 flow).
+        if (attributes["year"] === undefined && parsed["dash_year"] !== undefined) {
+            const dashYear = (extractValue(parsed["dash_year"]) ?? "").replace(/^[-:]/, "");
+            if (/^\d{4}$/.test(dashYear))
+                attributes["year"] = dashYear;
+        }
         // The IEEE-led tail word-stage ("IEEE/ISO/IEC P15026-3/CD,
         // December 2021") composes the D= designator with the glued
         // 6-digit date — the identity its D= twin spelling parses to (the
@@ -925,7 +1024,22 @@ class IeeeBuilder {
         }
         if (parsed["draft_version"] !== undefined) {
             const draftVer = (extractValue(parsed["draft_version"]) ?? "").replace(/^D/, "");
-            if (draftVer !== "") {
+            // FCD is an ISO stage (the 2026-10-19 ruling): a glued month-name
+            // date rides the designator's date slot with the month numeric —
+            // the D= designator face, never the "DFCD" glue.
+            const stageDate = /^(FDIS|FCD|CDV|DIS|CD|WD|PWI|NP)(\d+)?(?:-([A-Za-z]+)(\d{4}))?$/.exec(draftVer);
+            if (stageDate !== null) {
+                const monthNum = stageDate[3] !== undefined ? DRAFT_MONTH_NAMES[stageDate[3]] : undefined;
+                const stageWord = stageDate[1] + (stageDate[2] ?? "");
+                attributes["ieee_draft"] =
+                    stageDate[3] !== undefined && monthNum !== undefined
+                        ? `D=${stageWord}-${stageDate[4]}${monthNum.padStart(2, "0")}`
+                        : `D=${stageWord}`;
+                delete attributes["draft"];
+                delete attributes["year"];
+                delete attributes["month"];
+            }
+            else if (draftVer !== "") {
                 // A date trailing the draft (", June 2010") belongs to the draft
                 // component (canonical month, comma form); the identity
                 // year/month the promotion filled from the same captures are
@@ -1115,11 +1229,45 @@ class IeeeBuilder {
             }
             return new StandardClass(printedAttrs);
         }
+        // A stage word with a glued year tail ("/D=CD2-201802") rides the
+        // D= designator with the IEEE lead (the reference's builder, the
+        // pubid#203 class) — the tail's capture carries its separator.
+        if (parsed["iso_stage"] !== undefined && parsed["draft_stage_year"] !== undefined) {
+            const stageWord = extractValue(parsed["iso_stage"]) ?? "";
+            const pubs = (attributes["publishers"] ?? []);
+            if (pubs.length === 0) {
+                attributes["publishers"] = ["IEEE"];
+                attributes["publisher"] = "IEEE";
+                attributes["copublisher"] = [];
+            }
+            attributes["ieee_draft"] = `D=${stageWord}${extractValue(parsed["draft_stage_year"]) ?? ""}`;
+            const stageRecord = locateStage(stageWord);
+            if (stageRecord !== undefined) {
+                attributes["typed_stage"] = new IeeeTypedStage(stageRecord);
+            }
+            attributes["lead_party"] = "IEEE";
+            delete attributes["year"];
+            delete attributes["month"];
+        }
         if (parsed["iso_stage"] !== undefined) {
-            attributes["lead_party"] = "ISO";
-            const stageAbbr = extractValue(parsed["iso_stage"]);
-            attributes["iso_stage"] = stageAbbr;
-            if (stageAbbr !== undefined) {
+            // A bare-IEEE project carrying a stage never elects the ISO lead
+            // (the reference's bare_ieee_project gate): the lead stays IEEE.
+            const bareIeeeProject = parsed["project_marker"] !== undefined &&
+                attributes["publisher"] === "IEEE" &&
+                (attributes["copublisher"] ?? []).length === 0;
+            if (!bareIeeeProject)
+                attributes["lead_party"] = "ISO";
+            let stageAbbr = extractValue(parsed["iso_stage"]);
+            // The IEC "/V<version>" iteration rides glued onto the stage word
+            // ("_CDV/V3" -> "CDV3") — the family's lossless spelling (the
+            // reference's builder, pubid#477).
+            const stageIteration = extractValue(parsed["iso_stage_iteration"]);
+            if (stageAbbr !== undefined && stageIteration !== undefined) {
+                stageAbbr += stageIteration;
+            }
+            if (!bareIeeeProject)
+                attributes["iso_stage"] = stageAbbr;
+            if (stageAbbr !== undefined && !bareIeeeProject) {
                 const record = locateStage(stageAbbr);
                 if (record !== undefined)
                     attributes["typed_stage"] = new IeeeTypedStage(record);
@@ -1185,6 +1333,18 @@ class IeeeBuilder {
             }
             return new ProjectDraftIdentifierClass(projectAttrs);
         }
+        // The iso_published joint rows normalize the publisher order to
+        // ISO-first (the reference: "IEEE/ISO/IEC 8802-3:2021/Amd 4-2021"
+        // builds the base [ISO, IEC, IEEE], lead ISO); the CD-stage rows and
+        // the IEEE-led project rows preserve the printed order (P90003 stays
+        // IEEE/ISO/IEC).
+        if (parsed["iso_published"] !== undefined && parsed["iso_stage"] === undefined &&
+            Array.isArray(attributes["publishers"])) {
+            const pubs = attributes["publishers"];
+            attributes["publishers"] = [...pubs.filter((p) => p !== "IEEE"), ...pubs.filter((p) => p === "IEEE")];
+            attributes["publisher"] = attributes["publishers"][0];
+            attributes["copublisher"] = attributes["publishers"].slice(1);
+        }
         const joint = new JointDevelopmentClass(attributes);
         if (parsed["amd_number"] === undefined)
             return joint;

package/dist/flavors/ieee/model.js

@@ -1114,8 +1114,9 @@ export const JointDevelopmentClass = ieeeClass({ kind: "joint-development" }, {
         iso_stage: { type: "string" },
         ieee_draft: { type: "string" },
         parenthetical_content: { type: "string" },
+        draft_status: { 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" }, { wire: "parenthetical_content", to: "parenthetical_content" }),
+    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" }, { wire: "draft_status", to: "draft_status" }),
     wireDelete: { keys: ["publisher", "copublisher"] },
     render: (id) => {
         const publishers = id["publishers"];
@@ -1194,6 +1195,11 @@ export const JointDevelopmentClass = ieeeClass({ kind: "joint-development" }, {
         const parts = [];
         if (publishers !== undefined && publishers.length > 0)
             parts.push(publishers.join("/"));
+        // A status word ("Unapproved") marks the draft (pubid#318) — it
+        // prints after the publishers on the joint IEEE face.
+        const draftStatus = id["draft_status"];
+        if (draftStatus !== undefined)
+            parts.push(draftStatus);
         // The P-state prints as spelled (P = project draft; no P =
         // standard). Never added or stripped.
         let codeStr = codeObj?.render() ?? "";

package/dist/flavors/ieee/preprocessor.js

@@ -226,14 +226,11 @@ function normalizeRelatonSuffixes(input) {
             cleaned = `${m[1]}${date}${draftPart}/R-${m[3]}`;
         }
     }
-    // /D-N drafts with a trailing numeric date: reposition onto the number.
-    {
-        const re = /^(.*)\/D-([0-9A-Za-z][0-9A-Za-z.+]*?)-((?:19|20)\d\d)(?:-(0[1-9]|1[0-2]))?$/;
-        const m = re.exec(cleaned);
-        if (m !== null) {
-            cleaned = `${m[1]}-${m[3]}${m[4] !== undefined ? `-${m[4]}` : ""}/D${m[2]}`;
-        }
-    }
+    // The "/D-N-YYYY" draft-dash-date spelling is NOT repositioned: the
+    // artifact grammar reads it natively (draft + printed_dash_year) and
+    // the joint route renders the reference's dash-year face. The former
+    // reposition onto the number predated the artifact and broke the
+    // joint classification (the year left the designator's slot).
     // /E-N editions: "/E-2-2023-02" → "Edition 2.0 2023-02".
     {
         const re = /^(.*?)\/E-(\d+)(?:-((?:19|20)\d\d)(?:-(0[1-9]|1[0-2]))?)?$/;
@@ -255,10 +252,14 @@ function normalizeRelatonSuffixes(input) {
 }
 function normalizeRevisionNotation(input) {
     let cleaned = input;
-    // Numbered revisions preserved, repositioned to "/R-<n>".
-    cleaned = cleaned.replace(/(\/D-?[0-9A-Za-z.]+)\s+[Rr][Ee][Vv]\s*(\d+)/, "$1/R-$2");
-    cleaned = cleaned.replace(/[-/_.]?\s?[Rr][Ee][Vv][-\s]?(\d+)(\/D-?[0-9A-Za-z.]+)/, "$2/R-$1");
-    cleaned = cleaned.replace(/(\d)[-._]?\s?[Rr][Ee][Vv]\s*(\d+)\s*$/, "$1/R-$2");
+    // The reference's two glue-normalizing gsubs (parser.rb): a "REV.x"/
+    // "REV-x" after-word separator and a digit-glued "2rev1" normalize to
+    // a spaced boundary; the render keeps the glued face. The former
+    // /R-<n> reposition rules predate the artifact grammar and diverged
+    // from the reference (they ate "-rev1" spellings the artifact
+    // captures natively, which cost the glued-date rows their parse).
+    cleaned = cleaned.replace(/(REV|Rev|rev)[.\-](?=[A-Za-z])/g, "$1");
+    cleaned = cleaned.replace(/(\d)(REV|Rev|rev)/g, "$1 $2");
     // The joint IEEE/CSA catalogue spells the type word before the
     // project number ("IEEE/CSA Draft P844.1/D2, Sept, 2016"): the P
     // already carries the project semantics (docs/IEEE-DRAFT-STAGES.md
@@ -322,6 +323,12 @@ function normalizeJointStageSpellings(input) {
     // dash-date, and rewriting it onto the number breaks the parse.
     cleaned = cleaned.replace(new RegExp(`^${pubs}${num}/ ?${stage}(-(?:19|20)\\d\\d(?:-\\d\\d)?)`), "$1$3 $2$4");
     cleaned = cleaned.replace(new RegExp(`^${pubs}${stage} ${num}/? ?(D\\d+)\\b`), "$1$2 $3/$4");
+    // The dash-stage-with-part spelling ("ISO/IEC/IEEE P15288-DIS-1403",
+    // "… P12207-FDIS-1707, June 2017"): the stage glues between the number
+    // and the part. The reference renders the stage-first dot face
+    // ("DIS P15288.1403") — re-spell so the stage-first route parses it
+    // (a stage WITHOUT a trailing part, "P29119-2-DIS", routes elsewhere).
+    cleaned = cleaned.replace(new RegExp(`^${pubs}P?(\\d+)-(FDIS|DIS|CDV|CD|WD)(\\d*)-(\\d+(?:\\.\\d+)*)((?:, [A-Za-z]+ \\d{4})?)$`), "$1$3$4 P$2.$5$6");
     return cleaned;
 }
 // The Parser.parse cleaning pipeline, in Ruby order.
@@ -341,11 +348,19 @@ export function preprocessIeee(input) {
     cleaned = cleaned.replaceAll("&#x2019;", "'");
     cleaned = cleaned.replaceAll("&amp;amp;", "&");
     cleaned = cleaned.replaceAll("&amp;", "&");
-    cleaned = cleaned.replace(/\s+(P&V)\s*$/, " ($1)");
+    // The "P&V" print tail is NOT parenthesized: the artifact captures it
+    // and the builder discards it (the reference renders "ANSI/IEEE
+    // 500-1984" bare) — the former wrap made the parenthetical print.
     cleaned = cleaned.replace(/(\d+\.\d+)\s+(\d+\.)/g, "$1$2");
     cleaned = cleaned.replace(/\b(1|2)\s+(\d{3})\b/g, "$1$2");
-    cleaned = cleaned.replace(/\b(January|February|March|April|May|June|July|August|September|October|November|December)(\d{4})\b/g, "$1 $2");
-    cleaned = cleaned.replace(/\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)(\d{4})\b/g, "$1 $2");
+    // The month-year glue split ("June2010" -> "June 2010") is NOT the
+    // reference's behavior — the reference keeps the glue (the FCD ruling:
+    // "FCD-June2010" is the stage + the glued month-name date), and the
+    // split cost the FCD rows their classification.
+    // The 8802-family IEEE-led joint prefix reorders to the ISO/IEC/IEEE
+    // label (the reference's Fix 2AA): "IEEE/ISO/IEC 8802-1Q-2020" parses
+    // under the ISO/IEC label and the amendment route renders ISO-first.
+    cleaned = cleaned.replace(/^IEEE\/ISO\/IEC\s+(8802[\w.-]+)/, "ISO/IEC/IEEE $1");
     cleaned = normalizeJointStageSpellings(cleaned);
     cleaned = cleaned.replace(/(IEC\s+\d+(?:-\d+)?(?::\d{4})?(?:\s+(?:First\s+)?[Ee]dition\s+\d+(?:\.\d+)?\s+\d{4}-\d{2})?)\s+(IEEE\s+Std\s+\S+|IEEE\s+\S+)/g, "$1; $2");
     cleaned = cleaned.replace(/^(IEC\s+\d+(?:-\d+)?):\d{4}(\s+(?:First\s+)?[Ee]dition\s+\d+(?:\.\d+)?\s+\d{4}-\d{2})/, "$1$2");

package/dist/flavors/ieee/update_codes.js

@@ -99,14 +99,12 @@ export const UPDATE_CODES = [
     { plain: "ISO/IEC/IEEE CD P26513/D1, August 2015", replacement: "ISO/IEC/IEEE P26513/D1, August 2015" },
     { plain: "IEEE Std P1073.1.3.4/D3.0", replacement: "IEEE Std P11073.00101" },
     { plain: "IEEE P802.1Qbu/03.0, July 2015", replacement: "IEEE P802.1Qbu/D-3.0-2015" },
-    { plain: "IEEE P802.11aqTM/013.0 October 2017", replacement: "IEEE P802.11aqTM/D-13.0-2017" },
     { plain: "IEC/IEEE P62271-37-013:2015 D13.4", replacement: "IEC/IEEE P62271.37-013/D-13.4-2015" },
     { plain: "ISO/IEC/IEEE DIS P42020:201x(E), June 2017", replacement: "ISO/IEC/IEEE DIS P42020-2017-06" },
     { plain: "ISO/IEC/IEEE DIS P16326/201x, December 2018", replacement: "ISO/IEC/IEEE DIS P16326-2018-12" },
     { plain: "ISO/IEC/IEEE/P21839, 2019(E)", replacement: "ISO/IEC/IEEE P21839-2019" },
     { plain: "ISO/IEC/IEEE CD2 P12207-2: 201x(E), February 2019", replacement: "ISO/IEC/IEEE CD2 P12207.2-2019-02" },
     { plain: "ISO/IEC/IEEE P42010.WD4:2019(E)", replacement: "ISO/IEC/IEEE P42010/D-4-2019" },
-    { plain: "IEC/IEEE P63195_CDV/V3, February 2020", replacement: "IEC/IEEE CDV P63195-2020-02" },
     { 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" },

package/dist/flavors/itu/model.js

@@ -185,6 +185,7 @@ const yearMapping = () => ({
         : new PubidDate({
             year: String(h["year"]),
             month: h["month"] === undefined || h["month"] === null ? undefined : String(h["month"]),
+            day: h["day"] === undefined || h["day"] === null ? undefined : String(h["day"]),
         }),
 });
 const monthMapping = () => ({
@@ -193,13 +194,21 @@ const monthMapping = () => ({
     toWire: (m) => m["date"]?.month,
     fromWire: () => undefined,
 });
+// An Operational Bulletin's printed day ("15.III.2016") serializes flat,
+// mirroring the reference's hash ("year"/"month"/"day" siblings).
+const dayMapping = () => ({
+    wire: "day",
+    to: "date",
+    toWire: (m) => m["date"]?.day,
+    fromWire: () => undefined,
+});
 /** StandardSerialization — the single-document whitelist. */
 const STANDARD_MAPPINGS = keyValue({ wire: "sector", to: "sector" }, { wire: "series", to: "series" }, codeKey("imp_marker", (c) => c.imp_marker), {
     wire: "number",
     to: "code",
     toWire: (m) => codeOf(m)?.number,
     fromWire: (h) => ituCodeFromHash(h),
-}, codeKey("series_suffix", (c) => c.series_suffix), codeKey("series_suffix_spaced", (c) => (c.series_suffix_spaced ? true : undefined)), codeKey("subseries", (c) => c.subseries), codeKey("parts", (c) => (c.parts.length > 0 ? c.parts : undefined)), codeKey("qualifier", (c) => c.qualifier), codeKey("qualifier_glued", (c) => (c.qualifier_glued ? true : undefined)), { wire: "series_word", to: "series_word" }, { wire: "series_dash", to: "series_dash" }, { wire: "attachment", to: "attachment" }, { wire: "range_end", to: "range_end" }, { wire: "version", to: "version" }, yearMapping(), monthMapping(), { wire: "language", to: "language" }, { wire: "common_text_twin", to: "common_text_twin" });
+}, codeKey("series_suffix", (c) => c.series_suffix), codeKey("series_suffix_spaced", (c) => (c.series_suffix_spaced ? true : undefined)), codeKey("subseries", (c) => c.subseries), codeKey("parts", (c) => (c.parts.length > 0 ? c.parts : undefined)), codeKey("qualifier", (c) => c.qualifier), codeKey("qualifier_glued", (c) => (c.qualifier_glued ? true : undefined)), { wire: "series_word", to: "series_word" }, { wire: "series_dash", to: "series_dash" }, { wire: "attachment", to: "attachment" }, { wire: "range_end", to: "range_end" }, { wire: "version", to: "version" }, yearMapping(), monthMapping(), dayMapping(), { wire: "language", to: "language" }, { wire: "common_text_twin", to: "common_text_twin" });
 /**
  * The Supplement block: sector/series/series_word are emitted ONLY for
  * the base-less series-only form; with a base they are redundant

package/dist/flavors/nist/index.js

@@ -373,9 +373,10 @@ function cast(type, value, h, policy, series = "") {
                 return undefined;
             const stripped = v.trim();
             const code = TRANSLATION_MAP[stripped.toLowerCase()] ?? stripped.toLowerCase();
-            // The gem's translation attr is the component; its to_s prefixes
-            // the space (" .uppl"), and the wire serializes that form.
-            return { translation_component: new NistTranslation({ code }), translation: ` ${code}` };
+            // The gem's Translation#to_s (short) renders the parenthesised
+            // suffix — the 1.x corpus shape ("(spa)", pubid#497); the wire
+            // serializes that form.
+            return { translation_component: new NistTranslation({ code }), translation: `(${code})` };
         }
         case "version": {
             const v = s(value);

package/dist/flavors/nist/model.js

@@ -157,8 +157,10 @@ export class NistTranslation {
     toWire() {
         return { code: this.code };
     }
+    // The 1.x corpus shape: the trailing parenthesised suffix "(spa)"
+    // (pubid#497); the mr face keeps the dotted form (".spa").
     render(format = "short") {
-        return format === "mr" ? `.${this.code}` : ` ${this.code}`;
+        return format === "mr" ? `.${this.code}` : `(${this.code})`;
     }
 }
 export class NistStage {
@@ -467,7 +469,7 @@ export class NistIdentifier extends BaseIdentifier {
         if (this.errata !== undefined)
             result += this.errata;
         if (this.index !== undefined)
-            result += "index";
+            result += "indx";
         if (this.insert !== undefined)
             result += "insert";
         if (this.section !== undefined)

package/package.json

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