@pubid/pubid 0.1.8 → 0.1.9

package/dist/flavors/ieee/model.js

@@ -117,7 +117,16 @@ export class IeeeCode {
         return result;
     }
 }
-const DRAFT_MONTH_NAMES = {
+// Canonical month spelling (mirrors the gem's CANONICAL_ABBREVIATIONS):
+// full names normalize onto the crawl abbreviation, and "September"
+// keeps its IEEE "Sept" form — the 3-letter "Sep" folds onto it, so
+// every spelling of September renders and hashes alike.
+const DRAFT_MONTH_CANONICAL = {
+    January: "Jan", February: "Feb", March: "Mar", April: "Apr",
+    June: "Jun", July: "Jul", August: "Aug", September: "Sept",
+    October: "Oct", November: "Nov", December: "Dec", Sep: "Sept",
+};
+export const DRAFT_MONTH_NAMES = {
     January: "1", February: "2", March: "3", April: "4", May: "5", June: "6",
     July: "7", August: "8", September: "9", October: "10", November: "11",
     December: "12", Jan: "1", Feb: "2", Mar: "3", Apr: "4", Jun: "6",
@@ -139,12 +148,27 @@ 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"];
+        // The grammar's ordered alternation captures the stage WITH its
+        // draft-marker D when the spelling doubles it ("=DDIS"): the marker
+        // is notation, the stage is the bare ISO/IEC token (the reference's
+        // Draft constructor strips it).
+        let stage = attrs["iso_stage"];
+        if (stage !== undefined && stage.startsWith("D") &&
+            ["PWI", "NP", "WD", "CD", "CDV", "DIS", "FDIS"].includes(stage.slice(1))) {
+            stage = stage.slice(1);
+        }
+        this.isoStage = stage;
         this.year = attrs["year"];
-        this.originalMonth = attrs["month"];
-        this.month = attrs["month"] !== undefined
-            ? DRAFT_MONTH_NAMES[String(attrs["month"])] ?? String(attrs["month"])
+        // Canonical month spelling: the crawl abbreviation ("September" →
+        // "Sept"); the 3-letter "Sep" folds onto the IEEE "Sept" form, so
+        // every spelling of September renders — and hashes — alike.
+        const rawMonth = attrs["month"];
+        this.originalMonth = rawMonth !== undefined
+            ? DRAFT_MONTH_CANONICAL[rawMonth.replace(/\.$/, "")] ?? rawMonth
+            : undefined;
+        this.month = rawMonth !== undefined
+            ? DRAFT_MONTH_NAMES[String(this.originalMonth)] ?? String(this.originalMonth)
             : undefined;
         this.day = attrs["day"];
         this.commaBeforeMonth = attrs["comma_before_month"] === true;
@@ -363,10 +387,17 @@ export class IeeeIdentifier extends BaseIdentifier {
         draft_status: { type: "string" },
         draft: { type: "string" },
         revision: { type: "string" },
+        rev_sep: { type: "string" },
+        rev_bare: { type: "boolean" },
         edition: { type: "string" },
         month: { type: "string" },
         day: { type: "string" },
         redline: { type: "boolean", default: false },
+        // Provenance (gem#520): the month arrived glued to the identity year
+        // on the code ("ANSI/IEEE 21-1976-11") rather than as a trailing
+        // print date. The render keys on the month being numeric; this
+        // records how it arrived.
+        month_glued: { type: "boolean", default: false },
         edition_month: { type: "string" },
         space_before_draft: { type: "boolean", default: false },
         typed_stage: { type: IeeeTypedStage },
@@ -384,7 +415,7 @@ export class IeeeIdentifier extends BaseIdentifier {
         interpretation: { type: "boolean", default: false },
         relationships: { type: "string", collection: true },
     });
-    static mappings = keyValue({ wire: "publisher", to: "publisher" }, { wire: "copublisher", to: "copublisher" }, { wire: "year", to: "year" }, { wire: "type", to: "type" }, { wire: "draft_status", to: "draft_status" }, draftWire, { wire: "revision", to: "revision" }, { wire: "edition", to: "edition" }, { wire: "month", to: "month" }, { wire: "day", to: "day" }, { wire: "redline", to: "redline" }, { wire: "edition_month", to: "edition_month" }, { wire: "space_before_draft", to: "space_before_draft" }, typedStageWire, { wire: "parenthetical_content", to: "parenthetical_content" }, { wire: "nickname", to: "nickname" }, { wire: "adoption", to: "adoption" }, { wire: "amendment_to", to: "amendment_to" }, { wire: "note", to: "note" }, { wire: "iso_identifier", to: "iso_identifier" }, { wire: "revision_of", to: "revision_of" }, { wire: "ashrae_number", to: "ashrae_number" }, { wire: "ashrae_year", to: "ashrae_year" }, { wire: "crossref", to: "crossref" }, { wire: "reaffirmed", to: "reaffirmed" }, { wire: "interpretation", to: "interpretation" }, {
+    static mappings = keyValue({ wire: "publisher", to: "publisher" }, { wire: "copublisher", to: "copublisher" }, { wire: "year", to: "year" }, { wire: "type", to: "type" }, { wire: "draft_status", to: "draft_status" }, draftWire, { wire: "revision", to: "revision" }, { wire: "rev_sep", to: "rev_sep" }, { wire: "rev_bare", to: "rev_bare" }, { wire: "edition", to: "edition" }, { wire: "month", to: "month" }, { wire: "day", to: "day" }, { wire: "redline", to: "redline" }, { wire: "month_glued", to: "month_glued" }, { wire: "edition_month", to: "edition_month" }, { wire: "space_before_draft", to: "space_before_draft" }, typedStageWire, { wire: "parenthetical_content", to: "parenthetical_content" }, { wire: "nickname", to: "nickname" }, { wire: "adoption", to: "adoption" }, { wire: "amendment_to", to: "amendment_to" }, { wire: "note", to: "note" }, { wire: "iso_identifier", to: "iso_identifier" }, { wire: "revision_of", to: "revision_of" }, { wire: "ashrae_number", to: "ashrae_number" }, { wire: "ashrae_year", to: "ashrae_year" }, { wire: "crossref", to: "crossref" }, { wire: "reaffirmed", to: "reaffirmed" }, { wire: "interpretation", to: "interpretation" }, {
         wire: "relationships",
         to: "relationships",
         toWire: (model) => {
@@ -446,6 +477,12 @@ export function renderIeeeBase(id) {
         let typeStr = id.type;
         if (typeStr.startsWith("P"))
             typeStr = typeStr.slice(1);
+        // A draft carries the word Draft alone in every face (the C2
+        // ruling): Std/Standard never renders on a draft - a status-less
+        // draft ("IEEE Draft Std P802.3/D2.0") renders "IEEE Draft
+        // P802.3/D2.0".
+        if (id.draft !== undefined && id.draft_status === undefined)
+            typeStr = "Draft";
         if (typeStr.trim() !== "")
             parts.push(typeStr);
     }
@@ -455,6 +492,8 @@ export function renderIeeeBase(id) {
     // dates (catalogue metadata, not identity); wider sets and
     // space-separated dates print as spelled.
     const iecIeeOnly = id.publisher === "IEC" && JSON.stringify(id.copublisher) === '["IEEE"]';
+    // Short format = numeric month (glued face); the comma face is a month name.
+    const gluedMonth = /^\d{1,2}$/.test(id.month ?? "");
     if (codeObj !== undefined) {
         let result = codeObj.render();
         // Prepend P if this is a project AND code doesn't already have P.
@@ -467,11 +506,29 @@ export function renderIeeeBase(id) {
             !result.startsWith("P")) {
             result = `P${result}`;
         }
-        if (id.year !== undefined && draftObj === undefined && id.edition === undefined && id.month === undefined) {
+        // A base year dash-attaches to the code when nothing else carries
+        // it: no edition, no identity-month date - and either no draft at
+        // all, or a draft that carries its OWN date (the draft+corrigendum
+        // family: "PC37.09-1999/D7.2, Nov 2006").
+        // A numeric identity month is the SHORT format: the year stays on
+        // the code and the month dash-joins after it, whatever the input
+        // spelling ("IEEE P15026.1, 05 2014" renders "P15026.1-2014-05").
+        const yearOnCode = id.year !== undefined && id.edition === undefined &&
+            (id.month === undefined || gluedMonth) &&
+            (draftObj === undefined || draftObj.year !== undefined);
+        if (yearOnCode) {
             result += `-${id.year}`;
         }
+        if (gluedMonth && id.month !== undefined) {
+            result += `-${id.month}`;
+        }
+        // The lettered revision keeps its printed separator ("P802.11-REVmc"
+        // renders "P802.11-Revmc"); the bare word with no id still prints
+        // "Rev" (pubid ruling 2026-10-14).
         if (id.revision !== undefined)
-            result += `Rev${id.revision}`;
+            result += `${id.rev_sep ?? ""}Rev${id.revision}`;
+        if (id.rev_bare === true)
+            result += `${id.rev_sep ?? ""}Rev`;
         if (draftObj !== undefined) {
             let printed = draftObj.render();
             // The draft designator carries its date on every lead
@@ -510,13 +567,21 @@ export function renderIeeeBase(id) {
         parts.push(editionStr);
     }
     let result = parts.join(" ");
-    if (id.month !== undefined && !iecIeeOnly) {
+    if (id.month !== undefined && !gluedMonth && !iecIeeOnly) {
         result += `, ${id.month}`;
         if (id.day !== undefined)
             result += ` ${id.day}`;
         if (id.year !== undefined && id.edition === undefined)
             result += ` ${id.year}`;
     }
+    else if (id.year !== undefined && draftObj !== undefined && id.edition === undefined &&
+        draftObj?.year === undefined && !iecIeeOnly) {
+        // A year-only date trailing the draft ("ANSI N42.34/D9a, 2015")
+        // keeps its comma form instead of being silently dropped; a year
+        // whose draft carries its own date dash-attached to the code above
+        // and never repeats.
+        result += `, ${id.year}`;
+    }
     const parentheticals = [];
     if (id.reaffirmed !== undefined && id.reaffirmed.trim() !== "") {
         parentheticals.push(`(R${id.reaffirmed})`);
@@ -559,6 +624,13 @@ class IeeeUrnGenerator extends BaseUrnGenerator {
             push("redline");
         if (special === undefined && id.interpretation === true)
             push("int");
+        // A NESC preprint is a draft-stage document distinct from the
+        // published edition it precedes — without this component it would
+        // share the edition's URN (urn:ieee:ieee:C2:2012).
+        if (id.constructor.polymorphicName ===
+            "pubid:ieee:nesc-preprint") {
+            push("preprint");
+        }
         if (id.ashrae_number !== undefined) {
             let ashrae = `ashrae.${id.ashrae_number}`;
             if (id.ashrae_year !== undefined)
@@ -836,8 +908,14 @@ export const SiStandardClass = ieeeClass({ kind: "si-standard" }, {
                 result += ` ${part}`;
             }
         }
-        if (id.month !== undefined && id.year !== undefined)
-            result += `, ${id.month} ${id.year}`;
+        if (id.month !== undefined && id.year !== undefined) {
+            // Short format (numeric month) renders glued; the comma marks a
+            // month name (the long format).
+            if (/^\d{1,2}$/.test(id.month))
+                result += `-${id.year}-${id.month}`;
+            else
+                result += `, ${id.month} ${id.year}`;
+        }
         else if (id.year !== undefined)
             result += `-${id.year}`;
         return result;
@@ -1030,16 +1108,28 @@ export const JointDevelopmentClass = ieeeClass({ kind: "joint-development" }, {
         // P-state is identity-bearing and prints as spelled - it is never
         // added or stripped here.
         if (leadParty === "ISO") {
+            // A D= designator row ("P26511/D8=DDIS.3") prints the designator
+            // after the code, not the stage as a word; only genuine stage
+            // rows print the stage position.
+            const designatorDraft = id["ieee_draft"];
+            const printsDesignator = designatorDraft !== undefined && /^D\d*=/.test(designatorDraft);
             const parts = [];
             if (publishers !== undefined && publishers.length > 0)
                 parts.push(publishers.join("/"));
-            if (id.typed_stage !== undefined) {
-                parts.push(id.typed_stage.record.iso_stage_equivalent ?? id.typed_stage.render());
-            }
-            else if (isoStage !== undefined) {
-                parts.push(isoStage);
+            if (!printsDesignator) {
+                if (id.typed_stage !== undefined) {
+                    parts.push(id.typed_stage.record.iso_stage_equivalent ?? id.typed_stage.render());
+                }
+                else if (isoStage !== undefined) {
+                    parts.push(isoStage);
+                }
             }
-            const codeStr = codeObj?.render() ?? "";
+            let codeStr = codeObj?.render() ?? "";
+            // A P-prefixed joint project prints its parts dot-joined on the
+            // ISO face ("ISO/IEEE DIS P15500.1"), whatever separator the
+            // parse captured ("IEC/IEEE FDIS P60214-2-2018(E)" aliases in).
+            if (codeStr.startsWith("P"))
+                codeStr = codeStr.replaceAll("-", ".");
             if (codeStr !== "")
                 parts.push(codeStr);
             let result = parts.join(" ");
@@ -1049,12 +1139,16 @@ export const JointDevelopmentClass = ieeeClass({ kind: "joint-development" }, {
             // 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="))
+            if (jointDraft !== undefined && /^D\d*=/.test(jointDraft))
                 result += `/${jointDraft}`;
             const marker = id["parenthetical_content"];
             if (marker !== undefined && /^[A-Z](?:\s*[/&]\s*[A-Z])*$/.test(marker)) {
                 result += ` (${marker})`;
             }
+            // The joint ISO-print redline is a distinct document (pubid#215):
+            // "15289:2015(E) - Redline".
+            if (id.redline === true)
+                result += " - Redline";
             return result;
         }
         // IEEE format
@@ -1074,6 +1168,8 @@ export const JointDevelopmentClass = ieeeClass({ kind: "joint-development" }, {
         let result = parts.join(" ");
         if (id.year !== undefined)
             result += `-${id.year}`;
+        if (id.redline === true)
+            result += " - Redline";
         return result;
     },
 });
@@ -1215,11 +1311,25 @@ export const NescDraftClass = ieeeClass({ kind: "nesc-draft" }, {
     extraMappings: NescMappings,
     render: (id) => {
         const parts = ["Draft National Electrical Safety Code"];
-        if (id.month !== undefined && id.year !== undefined)
-            parts.push(`, ${id.month} ${id.year}`);
+        if (id.month !== undefined && id.year !== undefined) {
+            if (/^\d{1,2}$/.test(id.month))
+                parts.push(` ${id.number}-${id.year}-${id.month}`);
+            else
+                parts.push(`, ${id.month} ${id.year}`);
+        }
         return parts.join("");
     },
 });
+// The NESC's own term for its pre-edition drafts: a draft STAGE of the
+// C2 code, not a variant. Canonical spelling is dotted and prefixed;
+// the dash, catalogue slash-tail and verbose proposal spellings are
+// aliases.
+export const NescPreprintClass = ieeeClass({ kind: "nesc-preprint" }, {
+    codeColumns: true,
+    extraDefs: NescDefs,
+    extraMappings: NescMappings,
+    render: (id) => `IEEE Std ${["C2", id.year, "Preprint"].filter((p) => p !== undefined).join(".")}`,
+});
 function nescNamePortion(id) {
     let name = "National Electrical Safety Code";
     if (id["registered"] === true)

package/dist/flavors/ieee/preprocessor.js

@@ -259,9 +259,9 @@ function normalizeRevisionNotation(input) {
     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");
-    // Lettered inline revisions stripped.
-    cleaned = cleaned.replace(/[-/_.]?\s?[Rr][Ee][Vv][-\s]?[A-Za-z0-9]+(?=\/D-?[0-9A-Za-z])/, "");
-    cleaned = cleaned.replace(/(\d)[Rr][Ee][Vv][A-Za-z0-9]+\s*$/, "$1");
+    // Lettered inline revisions are IDENTITY (pubid ruling 2026-10-14):
+    // the grammar captures them natively with their separator; the former
+    // strip rewrite here dropped the letters and is gone.
     return cleaned;
 }
 function normalizeJointStageSpellings(input) {
@@ -271,7 +271,6 @@ function normalizeJointStageSpellings(input) {
     const num = "(P?\\d+(?:[.-]\\d+)?)";
     const tail = "(,? (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)[a-z]* \\d{4}|$|-\\d{4}(?:-\\d\\d)?)";
     cleaned = cleaned.replace(/(\d)_D(\d)/g, "$1/D$2");
-    cleaned = cleaned.replace(/,(?=[A-Za-z])/, ", ");
     cleaned = cleaned.replace(new RegExp(`^${pubs}${num}/(D[\\d.]+)/ ?${stage}\\b`), "$1$4 $2/$3");
     cleaned = cleaned.replace(new RegExp(`^${pubs}${num}/ ${stage}${tail}`), "$1$3 $2$4");
     cleaned = cleaned.replace(new RegExp(`^${pubs}${num}/${stage} (\\d{4})\\b`), "$1$3 $2-$4");
@@ -287,7 +286,6 @@ function normalizeJointStageSpellings(input) {
 // The Parser.parse cleaning pipeline, in Ruby order.
 export function preprocessIeee(input) {
     let cleaned = input.replace(/\.pdf$/i, "");
-    cleaned = cleaned.replace(/_(FDIS|CDV|CD|DIS|WD|PWI|NP)/g, "/$1");
     cleaned = cleaned.replace(/\s+/g, " ");
     cleaned = cleaned.replace(/\b(ISO\/IEC\/IEEE|IEEE\/ISO\/IEC|IEEE\/IEC\/ISO|ISO\/IEEE|IEC\/IEEE|IEEE\/IEC|ISO\/IEC)\/ ?(FDIS|FCD|CDV|DIS\d?|CD\d?|WD|PWI|NP)\b/g, "$1 $2");
     cleaned = normalizeRevisionNotation(cleaned);
@@ -363,7 +361,6 @@ export function preprocessIeee(input) {
     if (/^(\d+[-.]\d+)\/D\d+/.test(cleaned)) {
         cleaned = `IEEE P${cleaned}`;
     }
-    cleaned = cleaned.replace(/\/Preprint\b/g, "");
     cleaned = cleaned.replaceAll("Proposed Revision of", "Revision of");
     cleaned = cleaned.replace(/\bammended\b/gi, "amended");
     cleaned = cleaned.replace(/(\/INT|\/Cor\s+\d+-\d{4})\./g, "$1");

package/dist/flavors/nist/grammar.js

@@ -70,8 +70,14 @@ function buildRules() {
     rule("simple_series", () => literalAlternation(SIMPLE_SERIES).as("series"));
     rule("number_suffix", () => str("U")
         .then(lowerLetter)
-        .or(letter.then(literalAlternation([
-        "ec", "ndex", "nsert", "rrata", "raft", "pp", "s", "t",
+        .or(
+    // An "r" directly followed by a digit is the revision marker
+    // (pubid#170), not a suffix — leave it for the edition rules.
+    str("r")
+        .then(digit)
+        .absent()
+        .then(letter, literalAlternation([
+        "ec", "ndex", "ndx", "nsert", "rrata", "raft", "pp", "s", "t",
         "hi", "iet", "ort", "r", "p",
     ]).absent(), digits.maybe())));
     rule("digits_with_suffix", () => digits.then(ref(rules, "number_suffix").then(digit.absent()).maybe()));
@@ -105,20 +111,23 @@ function buildRules() {
         .absent()
         .then(str("draft").absent(), (digits
         .then(literalAlternation(["supp", "sup"]), digit.absent(), letter.absent())
-        .or(digits.then(str("r"), digits, str("U"), lowerLetter), digits.then(str("r"), digits, letter), digits.as("number_only").then(str("r"), digits.as("edition_id")), digits.then(str("_"), digits, dash, digits, upperLetter.maybe()), lowerLetter.then(dash, digits), digits.then(str("pt"), digits, dash.absent()), digits.then(upperLetter), digits
+        .or(digits.then(str("r"), digits, str("U"), lowerLetter), digits.then(str("r"), digits, letter), digits.as("number_only").then(str("r"), digits.then(dot.then(digits).maybe()).as("edition_id")), digits.then(str("_"), digits, dash, digits, upperLetter.maybe()), lowerLetter.then(dash, digits), digits.then(str("pt"), digits, dash.absent()), digits.then(upperLetter), digits
         .as("number_only")
         .then(str("r"), letter.as("letter"))
-        .as("revision_letter"), str("r").then(letter).as("revision_letter_suffix"), str("r").then(digits.as("edition_id")).as("revision_simple"), str("NCNR"), str("PERMIS"), str("BFRL"), upperLetter.repeat(1, 3), rules["digits_with_suffix"]
+        .as("revision_letter"), str("r").then(letter).as("revision_letter_suffix"), str("r")
+        .then(digits.then(dot.then(digits).maybe()).as("edition_id"))
+        .as("revision_simple"), str("NCNR"), str("PERMIS"), str("BFRL"), upperLetter.repeat(1, 3), rules["digits_with_suffix"]
         .then(dash.then(monthAbbrev(), digits, slash).absent()), lowerLetter.then(digit.absent()))).as("second_number")));
+    const dottedDigits = () => digits.then(dot.then(digits).maybe());
     const editionInner = () => space
         .maybe()
-        .then(str("e"), digits.as("edition_id"))
+        .then(str("e"), dottedDigits().as("edition_id"))
         .as("edition_e")
         .or(space
-        .then(str("r"), digits.as("edition_id"), letter.as("edition_letter"))
-        .as("edition_r_with_space_letter"), space.then(str("r"), digits.as("edition_id")).as("edition_r_with_space"), str("r")
-        .then(digits.as("edition_id"), letter.as("edition_letter"))
-        .as("edition_r_no_space_letter"), str("r").then(digits.as("edition_id")).as("edition_r_no_space"), space
+        .then(str("r"), dottedDigits().as("edition_id"), letter.as("edition_letter"))
+        .as("edition_r_with_space_letter"), space.then(str("r"), dottedDigits().as("edition_id")).as("edition_r_with_space"), str("r")
+        .then(dottedDigits().as("edition_id"), letter.as("edition_letter"))
+        .as("edition_r_no_space_letter"), str("r").then(dottedDigits().as("edition_id")).as("edition_r_no_space"), space
         .maybe()
         .then(str("rev"), space.maybe(), digits.as("edition_id"))
         .as("edition_rev"), dash.then(match("[1-9]").as("edition_id"), digit.absent()).as("edition_historical"), dash

package/dist/flavors/nist/index.js

@@ -1,5 +1,13 @@
-import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
-import { nistGrammar } from "./grammar.js";
+import { PubidRuntime, toBuilderTree } from "../../parg/runtime.js";
+// The grammar runtime is the baked PARG artifact (pubid-grammar
+// artifacts/nist.json via the parsanol engine) — the same artifact the
+// gem runs, so grammar changes land once and this port cannot drift.
+// Only the preprocessor, builder and model are ported code.
+let cachedNistRuntime;
+function cachedRuntime(input) {
+    cachedNistRuntime ??= PubidRuntime.load("nist");
+    return cachedNistRuntime.parseShape(input);
+}
 import { preprocessNist } from "./preprocessor.js";
 import { NIST_CLASSES, NistCode, NistEdition, NistPart, NistStage, NistSupplement, NistTranslation, NistUpdate, NistVersion, NistVolume, SP_SUBSERIES, seriesPolicy, } from "./model.js";
 /**
@@ -1238,11 +1246,12 @@ export function nistGrammarImplementation() {
     return {
         parse(input) {
             const { cleaned, format } = preprocessNist(input);
-            const tree = parseGrammar(nistGrammar, cleaned);
-            if (typeof tree !== "object" || tree === null) {
-                throw new ParseFailed("NIST: unexpected parse tree", 0);
-            }
-            return builder.build(tree, format);
+            const base = cleaned.replace(/\s*\(all parts\)\s*$/, "");
+            const tree = toBuilderTree(cachedRuntime(base));
+            const marked = base !== cleaned
+                ? { ...tree, all_parts: true }
+                : tree;
+            return builder.build(marked, format);
         },
     };
 }

package/dist/flavors/nist/preprocessor.js

@@ -192,8 +192,16 @@ export function preprocessNist(input) {
     cleaned = cleaned.replace(/(\d)(v\d+[a-z]-[a-z])/g, "$1 $2");
     cleaned = cleaned.replace(/(\d)(v\d+[A-Z])/g, "$1 $2");
     cleaned = cleaned.replace(/(v\d+)([A-Z])-([A-Z])/g, (_m, v, a, b) => `${v}${a}-${b.toLowerCase()}`);
-    // normalize_edition_year_suffix
+    // normalize_edition_year_suffix — a dotted minor after the dot stays
+    // attached (pubid#170): "2006ed.1" → "e2006.1", never "e20061".
+    cleaned = cleaned.replace(/(\d{4})ed\.(\d+)/g, "e$1.$2");
     cleaned = cleaned.replace(/(\d{4})ed\./g, "e$1");
+    // normalize_glued_dotted_edition — a glued dotted e-edition needs the
+    // space the spaced form has (pubid#170): "800-53e2.1" → "800-53 e2.1".
+    // The minor is 1-2 digits; a 4-digit tail is the additional-text year of
+    // "NBS CIRC 11e2.1915", which keeps its existing tree. Dot-less "800-53e2"
+    // keeps its number-bound tree.
+    cleaned = cleaned.replace(/(\d)e(\d+\.\d{1,2})(?!\d)/g, "$1 e$2");
     // normalize_revision_with_letter
     cleaned = cleaned.replace(/(\d+)(r\d{1,2})([a-z])(?=-|[A-Z]|$)/g, (_m, n, r, l) => `${n}${r}${l.toUpperCase()}`);
     cleaned = cleaned.replace(/(\d+)(r\d{1,2})(?![a-zA-Z])(?=[A-Z]|-(?=[A-Z])|\/(?:upd|errata|insert))/g, "$1 $2");

package/dist/parg/runtime.d.ts

@@ -0,0 +1,25 @@
+import { PargRuntime as EngineRuntime } from "parsanol";
+export type { FieldRequirement, EntrySchema, Schema } from "parsanol";
+export { PargRuntime } from "parsanol";
+/** The artifacts directory: PARG_ARTIFACT_DIR, else the sibling
+ * pubid-grammar checkout of the pubid workspace, else the vendored copy
+ * shipped in the published package (refreshed by `npm run artifact`). */
+export declare function artifactsDir(): string;
+/** The pubid flavor runtime: loads baked artifacts from the workspace. */
+export declare class PubidRuntime extends EngineRuntime {
+    static artifactsDir(): string;
+    static load(grammar: string, entry?: string): EngineRuntime;
+}
+/**
+ * The artifact emits capture leaves ({value, line, column, offset,
+ * length}) and a top-level sequence of capture hashes. This mirrors the
+ * gem's Pubid::Parg::Backend.to_builder_hash: scalarize leaves, fold the
+ * top-level list into one hash (last key wins — parslet's sequence fold).
+ */
+export declare function toBuilderTree(shape: unknown): unknown;
+/**
+ * Strip the shape metadata an artifact parse carries (offset/line/column
+ * wrappers) down to the plain string/array capture tree the builders
+ * consume — the same tree shape the hand-written grammars produced.
+ */
+export declare function normalizeShape(node: unknown): unknown;

package/dist/parg/runtime.js

@@ -0,0 +1,76 @@
+//! The PARG artifact runtime for pubid: a thin adapter over the
+//! published `parsanol` npm package (the wasm engine), adding the
+//! pubid-workspace artifacts directory convention. No grammar code and
+//! no vendored engine copy live in this repo; the baked artifact is
+//! the contract and the engine ships from the registry.
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { PargRuntime as EngineRuntime } from "parsanol";
+export { PargRuntime } from "parsanol";
+/** Walk up from this module to the package root (which holds package.json). */
+function packageRoot() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (; !existsSync(join(dir, "package.json")); dir = dirname(dir)) {
+        if (dir === dirname(dir))
+            throw new Error("package.json not found above the parg runtime");
+    }
+    return dir;
+}
+/** The artifacts directory: PARG_ARTIFACT_DIR, else the sibling
+ * pubid-grammar checkout of the pubid workspace, else the vendored copy
+ * shipped in the published package (refreshed by `npm run artifact`). */
+export function artifactsDir() {
+    const env = process.env.PARG_ARTIFACT_DIR;
+    if (env)
+        return env;
+    const sibling = join(packageRoot(), "..", "pubid-grammar", "artifacts");
+    if (existsSync(sibling))
+        return sibling;
+    return join(packageRoot(), "vendor", "parg");
+}
+/** The pubid flavor runtime: loads baked artifacts from the workspace. */
+export class PubidRuntime extends EngineRuntime {
+    static artifactsDir() {
+        return artifactsDir();
+    }
+    static load(grammar, entry) {
+        return EngineRuntime.fromFile(join(artifactsDir(), `${grammar}.json`), entry);
+    }
+}
+/**
+ * The artifact emits capture leaves ({value, line, column, offset,
+ * length}) and a top-level sequence of capture hashes. This mirrors the
+ * gem's Pubid::Parg::Backend.to_builder_hash: scalarize leaves, fold the
+ * top-level list into one hash (last key wins — parslet's sequence fold).
+ */
+export function toBuilderTree(shape) {
+    const normalized = normalizeShape(shape);
+    if (Array.isArray(normalized) &&
+        normalized.length > 0 &&
+        normalized.every((n) => typeof n === "object" && n !== null && !Array.isArray(n))) {
+        return Object.assign({}, ...normalized);
+    }
+    return normalized;
+}
+/**
+ * Strip the shape metadata an artifact parse carries (offset/line/column
+ * wrappers) down to the plain string/array capture tree the builders
+ * consume — the same tree shape the hand-written grammars produced.
+ */
+export function normalizeShape(node) {
+    if (Array.isArray(node))
+        return node.map(normalizeShape);
+    if (typeof node === "object" && node !== null) {
+        const rec = node;
+        if (typeof rec["value"] === "string" && Object.keys(rec).length >= 1 &&
+            "offset" in rec) {
+            return rec["value"];
+        }
+        const out = {};
+        for (const [k, v] of Object.entries(rec))
+            out[k] = normalizeShape(v);
+        return out;
+    }
+    return node;
+}

package/dist/parg/suite.d.ts

@@ -0,0 +1,4 @@
+export { loadSuites, readSuite, runSuite, type Suite, type SuiteTest, type TestKind, } from "parsanol/suite";
+export { PubidRuntime } from "./runtime.js";
+/** The suites directory: PARG_SUITES_DIR, else beside the artifacts. */
+export declare function suitesDir(): string;

package/dist/parg/suite.js

@@ -0,0 +1,14 @@
+//! pgtest suite runner: re-exports the engine suite machinery from the
+//! published `parsanol` package; only the suites directory convention
+//! (sibling pubid-grammar checkout) is pubid-specific.
+export { loadSuites, readSuite, runSuite, } from "parsanol/suite";
+export { PubidRuntime } from "./runtime.js";
+import { join } from "node:path";
+import { artifactsDir } from "./runtime.js";
+/** The suites directory: PARG_SUITES_DIR, else beside the artifacts. */
+export function suitesDir() {
+    const env = process.env.PARG_SUITES_DIR;
+    if (env)
+        return env;
+    return join(artifactsDir(), "..", "suites");
+}

package/dist/urn/parsers.js

@@ -552,6 +552,13 @@ export const URN_PARSERS = {
             const parts = splitParts(body);
             const [, code, year] = parts;
             let text = `IEEE Std ${code}`;
+            // A "-YYYY-MM" tail is a dated reference (year + numeric month),
+            // mirroring the gem's urn parser; it re-parses through the
+            // trailing-month-year clause so the render prints "21, 11 1976"
+            // like the reference.
+            const dated = /^(.*)-(\d{4})-(\d{2})$/.exec(text);
+            if (dated)
+                return parse(`${dated[1]}, ${dated[3]} ${dated[2]}`);
             if (year)
                 text += `-${year}`;
             return parse(text);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pubid/pubid",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "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",
@@ -17,15 +17,17 @@
     "artifact": "tsc -p tsconfig.json && node scripts/build-artifact.mjs"
   },
   "dependencies": {
+    "parsanol": "^0.10.3",
     "yaml": "^2.5.0"
   },
   "devDependencies": {
-    "typescript": "^5.6.0",
-    "@types/node": "^20.14.0"
+    "@types/node": "^20.14.0",
+    "typescript": "^5.6.0"
   },
   "files": [
     "dist",
-    "artifact"
+    "artifact",
+    "vendor/parg"
   ],
   "keywords": [
     "pubid",

package/vendor/parg/adobe.json

@@ -0,0 +1 @@
+{"bindings":null,"version":"0.1.0","grammar":"PubidAdobe","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Entity":{"atom":48}},{"Entity":{"atom":30}},{"Entity":{"atom":9}},{"Str":{"pattern":"Adobe"}},{"Entity":{"atom":5}},{"Str":{"pattern":" "}},{"Str":{"pattern":"TN"}},{"Entity":{"atom":5}},{"Repetition":{"atom":7,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[3,4,6,8]}},{"Entity":{"atom":24}},{"Str":{"pattern":"Adobe"}},{"Entity":{"atom":5}},{"Str":{"pattern":"Technical"}},{"Entity":{"atom":5}},{"Str":{"pattern":"Note"}},{"Entity":{"atom":5}},{"Repetition":{"atom":16,"min":0,"max":1,"tag":"Maybe"}},{"Str":{"pattern":"#"}},{"Repetition":{"atom":18,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":5}},{"Repetition":{"atom":20,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[17,19,21]}},{"Repetition":{"atom":22,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[11,12,13,14,15,23]}},{"Entity":{"atom":29}},{"Str":{"pattern":"ATN"}},{"Entity":{"atom":5}},{"Repetition":{"atom":27,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[26,28]}},{"Alternative":{"atoms":[2,10,25]}},{"Entity":{"atom":32}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Repetition":{"atom":31,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"number","atom":33}},{"Entity":{"atom":36}},{"Str":{"pattern":"."}},{"Entity":{"atom":42}},{"Re":{"pattern":"[\\x41-\\x5a]"}},{"Re":{"pattern":"[\\x61-\\x7a]"}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Re":{"pattern":"[_]"}},{"Alternative":{"atoms":[38,39,40,41]}},{"Repetition":{"atom":37,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"slug","atom":43}},{"Sequence":{"atoms":[35,44]}},{"Repetition":{"atom":45,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[1,34,46]}},{"Named":{"name":"tech_note","atom":47}},{"Entity":{"atom":53}},{"Entity":{"atom":32}},{"Repetition":{"atom":50,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"number","atom":51}},{"Named":{"name":"tech_note_bare","atom":52}},{"Entity":{"atom":87}},{"Str":{"pattern":"Adobe Publication "}},{"Repetition":{"atom":55,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":86}},{"Entity":{"atom":82}},{"Entity":{"atom":75}},{"Entity":{"atom":69}},{"Entity":{"atom":62}},{"Re":{"pattern":"[\\x61-\\x7a]"}},{"Repetition":{"atom":61,"min":1,"max":null,"tag":"Repetition"}},{"Entity":{"atom":67}},{"Re":{"pattern":"[\\x61-\\x7a]"}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Alternative":{"atoms":[65,66]}},{"Repetition":{"atom":64,"min":0,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[63,68]}},{"Entity":{"atom":71}},{"Str":{"pattern":"-"}},{"Entity":{"atom":69}},{"Sequence":{"atoms":[70,72]}},{"Repetition":{"atom":73,"min":0,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[60,74]}},{"Named":{"name":"slug","atom":59}},{"Entity":{"atom":71}},{"Entity":{"atom":32}},{"Repetition":{"atom":78,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"version","atom":79}},{"Sequence":{"atoms":[76,77,80]}},{"Named":{"name":"publication_version","atom":81}},{"Entity":{"atom":85}},{"Entity":{"atom":75}},{"Named":{"name":"slug","atom":84}},{"Alternative":{"atoms":[58,83]}},{"Sequence":{"atoms":[56,57]}},{"Alternative":{"atoms":[0,49,54]}}],"root":88},"bindings":[]}},"preprocess":{},"tables":{},"lint":{"order_warnings":["rule tech_note_prefix: branches 1 and 2 are order-dependent (shared first bytes; ordered choice is decisive)","rule tech_note_prefix: branches 1 and 3 are order-dependent (shared first bytes; ordered choice is decisive)","rule tech_note_prefix: branches 2 and 3 are order-dependent (shared first bytes; ordered choice is decisive)","rule publication_slug_or_version: branches 1 and 2 are order-dependent (shared first bytes; ordered choice is decisive)","rule identifier: branches 1 and 3 are order-dependent (shared first bytes; ordered choice is decisive)"]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"Adobe TN 15","expect":{}},{"entry":"identifier","kind":"accept","input":"ATN 30","expect":{}},{"entry":"identifier","kind":"accept","input":"Adobe Technical Note #12","expect":{}},{"entry":"identifier","kind":"reject","input":"###","expect":{}}],"docs":{},"source":"# Port of lib/pubid/adobe/parser.rb: tech notes (Adobe TN 5014, legacy\n# \"Adobe Technical Note #5014\", ATN5014, bare 5014) and publications\n# (adobe-glyph-list, adobe-japan1-7 with the version split tried first).\n\ngrammar PubidAdobe version \"0.1.0\" {\n  tech_note_tn_prefix = \"Adobe\" space \"TN\" [space]\n  tech_note_long_prefix = \"Adobe\" space \"Technical\" space \"Note\" [[space] [\"#\"] [space]]\n  tech_note_atn_prefix = \"ATN\" [space]\n  tech_note_prefix = tech_note_tn_prefix / tech_note_long_prefix / tech_note_atn_prefix\n  # Capture precedence: (*rep) as name wraps the whole repetition, so a\n  # digit run joins to one string instead of re-keying every character;\n  # slug is captured exactly once (the bare form) or as a sibling of\n  # version inside the publication_version capture.\n  tech_note = (tech_note_prefix (1*digit) as number [(dot (1*slug_char) as slug)]) as tech_note\n  bare_number = ((1*digit) as number) as tech_note_bare\n  slug_segment = 1*lower1 *lowerd\n  slug_text = slug_segment *(dash slug_segment)\n  slug_inner = (slug_text) as slug\n  publication_with_version = ((slug_text) as slug dash (1*digit) as version) as publication_version\n  publication_slug_or_version = publication_with_version / slug_inner\n  publication = [\"Adobe Publication \"] publication_slug_or_version\n  identifier = tech_note / bare_number / publication\n  slug_char = %x41-5A / %x61-7A / %x30-39 / %x5F\n  lower1 = %x61-7A\n  lowerd = %x61-7A / %x30-39\n  digit = %x30-39\n  space = \" \"\n  dot = \".\"\n  dash = \"-\"\n  entry identifier: identifier\n\n  test {\n    accept \"Adobe TN 15\"\n    accept \"ATN 30\"\n    accept \"Adobe Technical Note #12\"\n    reject \"###\"\n  }\n}\n","checksum":"sha256:38e8488c3da1c0f4a36fe2f63d87fee551d9317c5dae62f56972da1efe842a52"}