@pubid/pubid 0.1.36 → 0.1.38

package/dist/flavors/iho/index.js

@@ -43,7 +43,28 @@ function buildRules() {
     rule("part_edition_rule", () => space.then(digits.then(dot, digits, dot, digits).as("part_edition")));
     rule("part_year_rule", () => space.then(str("(").then(year4.as("part_year"), str(")"))));
     rule("part_dated", () => rules["part_edition_rule"].then(rules["part_year_rule"].maybe()));
-    rule("part", () => space.then(str("Part")).then(space, rules["part_value"], rules["part_dated"].maybe()));
+    // --- S-4 loose-leaf sections and specifications (issue #691) ---
+    // The spec number's vocabulary: the S-4 sections run 100-600 (Part C
+    // 100-500), so the leaf number is 3 digits with hundreds digit 1-6 —
+    // the same shape the bare citation branch leans on to keep the B
+    // Bibliographic series (B-1..B-13 style) distinct from B-4xx specs.
+    const specShape = match("[1-6]").then(match("[0-9]").repeat(2, 2));
+    // The citation letter is the spec's part (A/B/C); the builder binds
+    // it into `part` and rejects a conflicting Part-rule capture.
+    rule("spec_citation_body", () => str("A").or(str("B"), str("C")).as("spec_part")
+        .then(dash, specShape.as("spec"))
+        .then(dot.then(digits.as("spec_sub")).maybe())
+        .then(str("(").then(match("[A-Z]").repeat(1, Infinity).as("spec_variant"), str(")")).maybe()));
+    // The compact anchor form: the citation follows the code after one
+    // space ("IHO S-4 B-401").
+    rule("spec_citation", () => space.then(rules["spec_citation_body"]));
+    // The spelled section long form: "Part B, Section 400" — the spelled
+    // number becomes the spec (the section-level citation), and a
+    // trailing citation (", Section 400, B-401") makes it a cross-check
+    // only.
+    rule("part_section_tail", () => str(",").then(space, str("Section"), space, specShape.as("spec_section"))
+        .then(str(",").then(space, rules["spec_citation_body"]).maybe()));
+    rule("part", () => space.then(str("Part")).then(space, rules["part_value"], rules["part_dated"].maybe(), rules["part_section_tail"].maybe()));
     rule("supplement_edition_rule", () => space.then(digits.then(dot, digits, dot, digits).as("supplement_edition")));
     rule("supplement_year_rule", () => space.then(str("(").then(year4.as("supplement_year"), str(")"))));
     rule("supplement_dated", () => rules["supplement_edition_rule"].then(rules["supplement_year_rule"].maybe()));
@@ -79,8 +100,16 @@ function buildRules() {
     rule("identifier", () => str("IHO")
         .then(space)
         .maybe()
-        .then(rules["series"], dash, rules["number"], rules["compact_part"].maybe(), rules["glued"].maybe(), rules["volume_short"].maybe(), rules["dated"].maybe(), rules["supplement"].maybe(), rules["part"].maybe(), rules["annex"].maybe(), rules["appendix"].maybe(), rules["serial"].maybe(), rules["year_qualifier"].maybe()));
-    rule("root", () => rules["identifier"]);
+        .then(rules["series"], dash, rules["number"], rules["compact_part"].maybe(), rules["glued"].maybe(), rules["volume_short"].maybe(), rules["dated"].maybe(), rules["supplement"].maybe(), rules["part"].maybe(), rules["spec_citation"].maybe(), rules["annex"].maybe(), rules["appendix"].maybe(), rules["serial"].maybe(), rules["year_qualifier"].maybe()));
+    // The bare citation branch (the entry's FIRST alternative): "B-401" /
+    // "IHO B-401" — implicit S-4 anchor (the builder synthesizes series S
+    // number 4). B only: bare C-x stays the Circular Letter series, and
+    // the 3-digit [1-6]xx shape keeps the B Bibliographic series (B-12)
+    // on the main branch.
+    rule("bare_spec_citation", () => str("IHO").then(space).maybe()
+        .then(str("B").as("spec_part"), dash, specShape.as("spec"), dot.then(digits.as("spec_sub")).maybe(), str("(").then(match("[A-Z]").repeat(1, Infinity).as("spec_variant"), str(")")).maybe()));
+    rule("identifier_entry", () => rules["bare_spec_citation"].or(rules["identifier"]));
+    rule("root", () => rules["identifier_entry"]);
     return rules;
 }
 export const ihoGrammar = { rules: buildRules(), root: "root" };
@@ -115,8 +144,15 @@ function ihoClass(kind) {
             volume_edition: { type: "string" },
             volume_year: { type: "string" },
             issue: { type: "string" },
+            // The S-4 loose-leaf spec citation (issue #691): spec is the leaf
+            // number, the dotted sub and the parenthesized variant its
+            // children. The citation letter rides `part`; the spelled section
+            // is resolve-only (never an atom).
+            spec: { type: "string" },
+            spec_sub: { type: "string" },
+            spec_variant: { type: "string" },
         });
-        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "part_edition", to: "part_edition" }, { wire: "part_year", to: "part_year" }, { wire: "annex", to: "annex" }, { wire: "annex_edition", to: "annex_edition" }, { wire: "annex_year", to: "annex_year" }, { wire: "appendix", to: "appendix" }, { wire: "appendix_subnumber", to: "appendix_subnumber" }, { wire: "appendix_edition", to: "appendix_edition" }, { wire: "appendix_year", to: "appendix_year" }, { wire: "supplement", to: "supplement" }, { wire: "supplement_edition", to: "supplement_edition" }, { wire: "supplement_year", to: "supplement_year" }, { wire: "edition", to: "edition" }, { wire: "year", to: "year" }, { wire: "volume", to: "volume" }, { wire: "volume_edition", to: "volume_edition" }, { wire: "volume_year", to: "volume_year" }, { wire: "issue", to: "issue" });
+        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "part_edition", to: "part_edition" }, { wire: "part_year", to: "part_year" }, { wire: "annex", to: "annex" }, { wire: "annex_edition", to: "annex_edition" }, { wire: "annex_year", to: "annex_year" }, { wire: "appendix", to: "appendix" }, { wire: "appendix_subnumber", to: "appendix_subnumber" }, { wire: "appendix_edition", to: "appendix_edition" }, { wire: "appendix_year", to: "appendix_year" }, { wire: "supplement", to: "supplement" }, { wire: "supplement_edition", to: "supplement_edition" }, { wire: "supplement_year", to: "supplement_year" }, { wire: "edition", to: "edition" }, { wire: "year", to: "year" }, { wire: "volume", to: "volume" }, { wire: "volume_edition", to: "volume_edition" }, { wire: "volume_year", to: "volume_year" }, { wire: "issue", to: "issue" }, { wire: "spec", to: "spec" }, { wire: "spec_sub", to: "spec_sub" }, { wire: "spec_variant", to: "spec_variant" });
         render() {
             let result = `IHO ${letter}-${this.number}`;
             if (this.edition !== undefined)
@@ -128,7 +164,17 @@ function ihoClass(kind) {
                 if (this.supplement_year !== undefined)
                     result += ` (${this.supplement_year})`;
             }
-            if (this.part !== undefined) {
+            if (this.spec !== undefined) {
+                // The S-4 citation face replaces the Part face (same
+                // containment slot: the citation letter IS the part):
+                // "B-401", "B-122.1", "B-521(I)".
+                result += ` ${this.part}-${this.spec}`;
+                if (this.spec_sub !== undefined)
+                    result += `.${this.spec_sub}`;
+                if (this.spec_variant !== undefined)
+                    result += `(${this.spec_variant})`;
+            }
+            else if (this.part !== undefined) {
                 result += ` Part ${this.part}`;
                 if (this.part_edition !== undefined)
                     result += ` ${this.part_edition}`;
@@ -192,6 +238,17 @@ function ihoClass(kind) {
                 if (id.part_year !== undefined)
                     parts.push(`year-${id.part_year}`);
             }
+            // The S-4 spec citation: a child of its part (the citation letter
+            // rides the part- atom), the dotted sub and the parenthesized
+            // variant its own children. The spelled SECTION is NOT emitted —
+            // derivable from the spec's hundreds digit.
+            if (id.spec !== undefined) {
+                parts.push(`spec-${id.spec}`);
+                if (id.spec_sub !== undefined)
+                    parts.push(`specsub-${id.spec_sub}`);
+                if (id.spec_variant !== undefined)
+                    parts.push(`specvar-${id.spec_variant}`);
+            }
             if (id.annex !== undefined) {
                 parts.push(`annex-${id.annex}`);
                 if (id.annex_edition !== undefined)
@@ -235,6 +292,18 @@ const KIND_CLASSES = {
 };
 const LETTER_TO_CLASS = new Map(Object.keys(KIND_LETTERS).map((kind) => [KIND_LETTERS[kind], KIND_CLASSES[kind]]));
 class IhoBuilder extends BaseBuilder {
+    // The S-4 anchor: the loose-leaf publication every spec citation
+    // resolves through (bare "B-401" carries it implicitly).
+    static S4_TYPE = "S";
+    static S4_NUMBER = "4";
+    // A citation letter is one of S-4's lettered Parts; the section
+    // vocabulary (100-600, Part C 100-500) is theirs.
+    static SPEC_LETTERS = ["A", "B", "C"];
+    // Components an S-4 spec citation cannot carry: the citation is a
+    // leaf of the Part, not a wrappable publication.
+    static SPEC_FOREIGN_COMPONENTS = [
+        "supplement", "annex", "appendix", "appendix_subnumber", "volume", "issue",
+    ];
     selectClass(data) {
         const kind = LETTER_TO_CLASS.get(String(data["type"]));
         if (kind === undefined) {
@@ -264,6 +333,58 @@ class IhoBuilder extends BaseBuilder {
                 delete flat[yearKey];
             }
         }
+        // The S-4 spec citation resolution (ruby resolve_spec_citation!):
+        // the citation letter folds into `part` (a Part-rule capture must
+        // agree), and the long form's spelled section becomes the spec
+        // alone — beside a citation it only cross-checks the citation's
+        // derived section ("Part B, Section 400, B-401" stores spec 401;
+        // "Part B, Section 500, B-401" is rejected).
+        const letter = flat["spec_part"];
+        const spelled = flat["spec_section"];
+        delete flat["spec_part"];
+        delete flat["spec_section"];
+        if (letter !== undefined) {
+            if (flat["part"] === undefined || flat["part"] === letter) {
+                flat["part"] = letter;
+            }
+            else {
+                throw new ParseFailed(`IHO: the citation letter ${String(letter)} conflicts with part ${String(flat["part"])}`, 0);
+            }
+        }
+        if (spelled !== undefined) {
+            if (flat["spec"] === undefined) {
+                flat["spec"] = spelled;
+            }
+            else {
+                const section = `${String(flat["spec"])[0]}00`;
+                if (spelled !== section) {
+                    throw new ParseFailed(`IHO: the spelled section ${String(spelled)} disagrees with the citation ${String(flat["part"])}-${String(flat["spec"])}`, 0);
+                }
+            }
+        }
+        if (flat["spec"] !== undefined) {
+            if (!IhoBuilder.SPEC_LETTERS.includes(String(flat["part"]))) {
+                throw new ParseFailed(`IHO: an S-4 spec citation needs a lettered Part (A/B/C), not ${JSON.stringify(flat["part"])}`, 0);
+            }
+            if (flat["part_edition"] !== undefined || flat["part_year"] !== undefined) {
+                throw new ParseFailed("IHO: a spec citation rides the S-4 edition, not a part edition", 0);
+            }
+            const foreign = IhoBuilder.SPEC_FOREIGN_COMPONENTS.filter((k) => flat[k] !== undefined);
+            if (foreign.length > 0) {
+                throw new ParseFailed(`IHO: an S-4 spec citation is a leaf of its Part and cannot carry ${foreign.join(", ")}`, 0);
+            }
+            // The series letter: a bare citation branch parse has no series
+            // capture, and its anchor is implicitly the S-4 publication (the
+            // number binds with it). An explicit series must BE the anchor.
+            if (flat["type"] === undefined) {
+                flat["type"] = IhoBuilder.S4_TYPE;
+                flat["number"] = IhoBuilder.S4_NUMBER;
+            }
+            else if (flat["type"] !== IhoBuilder.S4_TYPE ||
+                flat["number"] !== IhoBuilder.S4_NUMBER) {
+                throw new ParseFailed(`IHO: an S-4 spec citation requires the S-4 anchor: ${String(flat["type"])}-${String(flat["number"])} cannot carry spec ${String(flat["spec"])}`, 0);
+            }
+        }
         return super.build(flat);
     }
     cast(key, value) {

package/dist/flavors/iso/grammar.d.ts

@@ -1,2 +1,7 @@
 import { Grammar } from "../../grammar/engine.js";
+/** The DAM-family ballot stage codes (grammar table
+ * typed_stages_ballots: PDAM, DAM, DAmd, FDAM, FDAmd, FPDAM — exactly
+ * these entries' abbrs); the TYPE-first ballot branch stays scoped to
+ * the ballot family. */
+export declare const BALLOT_STAGE_CODES: string[];
 export declare const isoGrammar: Grammar;

package/dist/flavors/iso/grammar.js

@@ -1,5 +1,6 @@
 import { match, ref, str } from "../../grammar/engine.js";
 import { stageTokens } from "./model.js";
+import { ISO_TYPED_STAGES } from "./stages.generated.js";
 /**
  * Port of lib/pubid/iso/parser.rb. The identifier alternation order is
  * load-bearing (PEG ordered choice): nsb_iso | tc_document |
@@ -9,6 +10,11 @@ import { stageTokens } from "./model.js";
  * supplement tables exactly like the Ruby TYPED_STAGES constants.
  */
 const SUPPLEMENT_TYPE_KEYS = ["amd", "cor", "suppl", "ext", "add"];
+/** The DAM-family ballot stage codes (grammar table
+ * typed_stages_ballots: PDAM, DAM, DAmd, FDAM, FDAmd, FPDAM — exactly
+ * these entries' abbrs); the TYPE-first ballot branch stays scoped to
+ * the ballot family. */
+export const BALLOT_STAGE_CODES = ["pdam", "damd", "fdamd", "fpdam"];
 const BASE_STAGE_TOKENS = stageTokens().filter((t) => {
     // Supplement tokens are excluded from the base table by type key, but
     // stageTokens() is type-agnostic here; the split is done via the
@@ -208,7 +214,68 @@ function buildRules() {
         .as("base")
         .then(space.maybe(), str("|"), space.maybe(), rules["idf_identifier"])
         .as("joint_identifier"));
-    rule("identifier", () => rules["bare_tc_document"].or(rules["nsb_iso_identifier"], rules["tc_document"], rules["directives_identifiers"], rules["jcgm_identifier"], rules["iso_r_supplement_identifier"], rules["iso_r_identifier"], rules["supplement_supplement_supplement_identifier"], rules["supplement_supplement_identifier"], rules["supplement_identifier"], rules["joint_identifier"], rules["identifier_copublishers"]));
+    // Historic TYPE-first ballot faces (decode-to-modern, owner ruling
+    // 2026-11-12): the DAM-family token in TYPE position — "ISO/IEC FDAM 1
+    // 14496-12:2004", "ISO/PDAM 19973-2" — and the space-attached ballot
+    // face "ISO 15877-5:2009 FDAM 1". Both branches sit LAST in the
+    // identifier alternation, so they are purely additive: every face an
+    // earlier branch parses keeps its exact parse. The ballot token
+    // captures as ballot_type_with_stage; a number on the TYPE token is
+    // space-bounded (ballot_number) so "PDAM 19973-2" keeps 19973 in the
+    // base; an on-base stamp's number/date capture as ballot_stamp_* (the
+    // stamp token itself matches uncaptured — the ballot's stage comes
+    // from the TYPE token and the decode keeps no spelling). The builder
+    // folds the captures into ONE amendment layer over the whole base, the
+    // number taken from the TYPE token, the stamp, or the implied 1.
+    const ballotStageTokens = ISO_TYPED_STAGES
+        .filter((st) => BALLOT_STAGE_CODES.includes(st.code))
+        .flatMap((st) => st.abbr);
+    const ballotTypeAlt = literalAlternation(ballotStageTokens).as("ballot_type_with_stage");
+    rule("ballot_type_with_stage", () => ballotTypeAlt);
+    // An on-base stamp riding a ballot face ("/Amd 9:2001", "/Amd.1",
+    // "/Am1:2006"): it carries the amendment's number and ballot date
+    // while its own token letters are decode-away (matched uncaptured).
+    // The stamp's date captures under its own ballot_stamp_* names —
+    // reusing the base date capture would collide with second_part's at
+    // the sequence merge and the stamp's year would eat the base's.
+    rule("ballot_stamp", () => str("/")
+        .then(literalAlternation(supplementTypeTokens))
+        .then(space
+        .maybe()
+        .then(digit.repeat(1, 5).as("ballot_stamp_number"))
+        .then(str(":")
+        .or(dash)
+        .then(yearDigits
+        .then(dash.then(monthDigits).maybe(), dash.then(dayDigits).maybe())
+        .as("ballot_stamp_date"))
+        .or(str(":")
+        .or(dash)
+        .then(str("--").or(str("—")).as("ballot_stamp_undated_marker")))
+        .maybe())
+        .or(str(".").then(digits.as("ballot_stamp_dot_number")))));
+    // "ISO/IEC FDAM 1 14496-12:2004", "ISO/PDAM 19973-2": the ballot
+    // token first, then the base kept whole. The TYPE-token number is
+    // space-bounded on both sides — mandatory trailing space — so
+    // "PDAM 19973-2" cannot read 19973 as the ballot number: with no
+    // second space the group backtracks and 19973 parses in second_part.
+    rule("ballot_supplement_identifier", () => rules["prefix_with_copublishers"]
+        .then(space.maybe(), str("/").maybe(), ballotTypeAlt, space.then(digit.repeat(1, Infinity).as("ballot_number")).then(space).maybe(), space.maybe(), rules["type_with_stage"].maybe(), space.maybe(), rules["second_part"], rules["ballot_stamp"].maybe()));
+    // The space-attached ballot face: "ISO 15877-5:2009 FDAM 1" — the
+    // base designation first, then the ballot token attached by a space.
+    // The base front is inlined (not identifier_copublishers_no_third):
+    // that rule ends in third_part_edition, whose own optional space
+    // would consume the separator the ballot token needs. No base
+    // edition is served here — none of the stored or owner-cited ballot
+    // faces carries one.
+    rule("ballot_space_supplement_identifier", () => rules["guide_prefix"]
+        .as("type_with_stage_fr")
+        .then(space)
+        .maybe()
+        .then(rules["prefix_with_copublishers"].maybe(), space.maybe(), str("/").maybe(), rules["type_with_stage"].maybe(), space.maybe(), rules["second_part"], space, ballotTypeAlt, space.then(digit.repeat(1, Infinity).as("ballot_number")).maybe()));
+    rule("identifier", () => rules["bare_tc_document"].or(rules["nsb_iso_identifier"], rules["tc_document"], rules["directives_identifiers"], rules["jcgm_identifier"], rules["iso_r_supplement_identifier"], rules["iso_r_identifier"], rules["supplement_supplement_supplement_identifier"], rules["supplement_supplement_identifier"], rules["supplement_identifier"], rules["joint_identifier"], rules["identifier_copublishers"], 
+    // The historic ballot faces go last — purely additive branches
+    // (an input an earlier member parses keeps that parse).
+    rules["ballot_supplement_identifier"], rules["ballot_space_supplement_identifier"]));
     rule("root", () => rules["identifier"]);
     return rules;
 }

package/dist/flavors/iso/index.js

@@ -1,6 +1,6 @@
 import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
 import { PubidDate, Language, Iteration } from "../../model/component.js";
-import { isoGrammar } from "./grammar.js";
+import { isoGrammar, BALLOT_STAGE_CODES } from "./grammar.js";
 import { IsoBundledIdentifier, IsoDirectives, IsoDirectivesSupplement, IsoEdition, IsoPublisher, IsoSupplementIdentifier, IsoTcDocument, isoClassForType, locateStage, } from "./model.js";
 import { ISO_TYPED_STAGES } from "./stages.generated.js";
 /**
@@ -232,6 +232,15 @@ class IsoBuilder {
     }
     buildStandard(treeIn) {
         const tree = { ...treeIn };
+        // Historic TYPE-first ballot face ("ISO/IEC FDAM 1 14496-12:2004",
+        // "ISO/PDAM 19973-2", "ISO 15877-5:2009 FDAM 1"): the ballot_* keys
+        // are one amendment layer over the whole base, never a second
+        // supplement layer (the stored twins keep one level), so the layer
+        // is assembled here, before the supplement branch could read the
+        // ballot token as an outer wrapper.
+        if (tree["ballot_type_with_stage"] !== undefined) {
+            return this.buildBallotSupplement(tree);
+        }
         // Legacy ISO/R: publisher ISO + type "R".
         if (tree["iso_r_prefix"] !== undefined) {
             tree["publisher"] = "ISO";
@@ -280,8 +289,63 @@ class IsoBuilder {
             attrs["base"] = this.build(tree["base"]);
         }
         const identifier = new klass(attrs);
+        // The owner's no-number rule, applied on every construction path
+        // that routes through this builder (parse, URN, bundle members): a
+        // DAM-family ballot-stage amendment token with no number anywhere
+        // names Amendment 1 ("ISO 19973-2/PDAM", "ISO/IEC PDAM 12207"). The
+        // number is identity-bearing, so the default lands at build time and
+        // the wire hash serializes it — parse and fromHash(toHash) agree
+        // because both carry the filled number. The ballot stages are
+        // matched by the typed stage's code (the per-typed-stage key) —
+        // PDAM's stageCode is "cd", the harmonized range it lives in.
+        if (typeKey === "amd" && attrs["number"] === undefined &&
+            BALLOT_STAGE_CODES.includes(attrs["typedStageState"]?.entry.code ?? "")) {
+            identifier["number"] = "1";
+        }
         return identifier;
     }
+    /**
+     * Historic TYPE-first ballot face (owner ruling 2026-11-12, Option B
+     * decode-to-modern): "[P|F]?DAM [N] BASE [stamp]" decodes to ONE
+     * amendment over the WHOLE base, rendered as the canonical on-base
+     * slash face. The stage comes from the ballot token; the number from
+     * the TYPE token, then the on-base stamp, then the owner's no-number
+     * rule (a ballot face with no number anywhere names Amendment 1); the
+     * stamp's date is the ballot supplement's date. The base keeps every
+     * component it carried: a legacy slash-part stays a part of the base
+     * number ("ISO/IEC FPDAM 9075/1" → base "9075-1"), and the base's own
+     * type token stays the base's ("ISO/IEC PDAM TR 9573-11" → base
+     * "TR 9573-11") — nothing migrates into the supplement slot. The
+     * stamp's token letters (Amd/Am/…) are decode-away: the ballot's
+     * stage is the TYPE token's.
+     */
+    buildBallotSupplement(tree) {
+        const fields = {
+            type_with_stage: s(tree["ballot_type_with_stage"]),
+        };
+        const number = s(tree["ballot_number"]) ??
+            s(tree["ballot_stamp_number"]) ??
+            s(tree["ballot_stamp_dot_number"]) ??
+            "1";
+        fields["number_with_part"] = number;
+        // The on-base stamp: its date (or undated marker) is the ballot
+        // supplement's; its number feeds the precedence above; its token
+        // letters were matched uncaptured and decode away.
+        const stampDate = s(tree["ballot_stamp_date"]);
+        if (stampDate !== undefined) {
+            const [year, month, day] = stampDate.split("-");
+            fields["date"] = new PubidDate({ year, month, day });
+        }
+        else if (tree["ballot_stamp_undated_marker"] !== undefined) {
+            fields["date"] = new PubidDate({ undated: true });
+        }
+        const rest = {};
+        for (const [key, value] of Object.entries(tree)) {
+            if (!key.startsWith("ballot_"))
+                rest[key] = value;
+        }
+        return this.build({ ...fields, base: rest });
+    }
     buildDirectives(tree, state) {
         const attrs = this.baseAttrs(tree);
         const publisher = this.publisherOf(tree);

package/dist/flavors/iso/model.js

@@ -102,8 +102,14 @@ export class IsoIdentifier extends BaseIdentifier {
         const ts = this.typedStageState;
         if (ts === undefined)
             return false;
-        if (ts.entry.longAbbr !== undefined && ts.originalAbbr?.startsWith(ts.entry.longAbbr))
+        if (ts.entry.longAbbr !== undefined && ts.originalAbbr !== undefined &&
+            (ts.originalAbbr.startsWith(ts.entry.longAbbr) ||
+                // The shorter long-family spellings ("Am", the alias of "Amd"
+                // the owner ruled renders canonical) are prefixes of the long
+                // abbr; the short family ("AMD") matches neither direction.
+                ts.entry.longAbbr.startsWith(ts.originalAbbr))) {
             return true;
+        }
         if (ts.entry.longAbbr !== undefined && ts.originalAbbr?.includes("Directives"))
             return true;
         return false;

package/dist/flavors/iso/stages.generated.js

@@ -32,7 +32,7 @@ export const ISO_TYPED_STAGES = [
         code: "prf_amd", stageCode: "prf", typeCode: "amd", abbr: ["PRF Amd"], harmonized: ["50.00"]
     }),
     TS("amd", {
-        code: "published", stageCode: "published", typeCode: "amd", abbr: ["Amd", "AMD", "Amd."], shortAbbr: "AMD", longAbbr: "Amd", harmonized: ["60.00", "60.60"]
+        code: "published", stageCode: "published", typeCode: "amd", abbr: ["Amd", "AMD", "Amd.", "Am"], shortAbbr: "AMD", longAbbr: "Amd", harmonized: ["60.00", "60.60"]
     }),
     TS("cor", {
         code: "pwi_cor", stageCode: "proposal", typeCode: "cor", abbr: ["PWI Cor"], harmonized: ["00.00", "00.20", "00.60", "00.92", "00.93", "00.98", "00.99"]

package/dist/flavors/nist/model.js

@@ -709,8 +709,24 @@ function nistClass(spec) {
                 return `${this.publisher ?? "NIST"} ${this.date_year ?? ""}-${this.date_month ?? ""}-${this.date_day ?? ""} ${this.dated_seq ?? ""}`;
             }
             if (spec.style === "fips") {
-                let result = this.publisher !== undefined ? `${this.publisher} ` : "";
-                result += this.seriesCode() ?? "";
+                // The official published face is "FIPS PUB <number>": FIPS is
+                // government-published and "PUB" (Federal Information Processing
+                // Standards PUBlication) is part of the official designation
+                // (owner ruling 2026-11-12). A spelled NIST publisher renders the
+                // official face; the historical NBS-prefixed rows keep
+                // "NBS FIPS <number>", and the bare publisher-less spelling keeps
+                // its short "FIPS <number>" face. The lead reads
+                // shortRenderPublisher() (the printed-publisher view), so a
+                // series-default publisher filled without being spelled (#704's
+                // ruby model) can never flip the bare face; the tail rides the
+                // lead.
+                const pub = this.shortRenderPublisher();
+                const series = this.seriesCode() ?? "";
+                let result = pub === "NIST"
+                    ? "FIPS PUB"
+                    : pub !== undefined && pub !== ""
+                        ? `${pub} ${series}`
+                        : series;
                 let numberPart = this.number ?? "";
                 const fy = /^(\d{1,3})-(\d{4})$/.exec(numberPart);
                 if (fy !== null) {

package/dist/flavors/nist/preprocessor.js

@@ -137,6 +137,17 @@ export function preprocessNist(input) {
     cleaned = cleaned.replace(/^(NBS|NIST)(IR|FIPS|GCR|HB|MONO|MP|NCSTAR|NSRDS)/i, "$1 $2");
     cleaned = cleaned.replace(/\b(ir|sp|tn|hb|fips|ams|vts)\b/i, (m) => m.toUpperCase());
     cleaned = cleaned.replace(/\bLC\b(?!IRC)/g, "LCIRC");
+    // normalize_fips_pub_alias: the FIPS series' official printed face is
+    // "FIPS PUB <number>" — FIPS is government-published and "PUB" (Federal
+    // Information Processing Standards PUBlication) is part of the official
+    // designation — and the RENDERER emits that face directly (owner ruling
+    // 2026-11-12, mirroring the gem). The grammar reads the
+    // publisher-bearing spelling only through this fold (pubid#697): the
+    // printed spellings — "FIPS PUB 205" and the publisher-prefixed
+    // "NIST FIPS PUB 205" (pubid#702) — fold onto the one model "NIST FIPS
+    // <number>" the grammar already builds (same hash, same URN, same MR
+    // string). Anchored at the head; bare "FIPS" is untouched.
+    cleaned = cleaned.replace(/^(?:NIST )?FIPS PUB\b/i, "NIST FIPS");
     // normalize_lcirc_supplement_contexts
     cleaned = cleaned.replace(/\bNBS LCIRC\b(?=.*\b(?:supp?|sup\+|r\d+\/)\d)/, "NBS.LCIRC");
     cleaned = cleaned.replace(/\bNBS\.LCIRC\.(\d+r\d+\/\d{4})/, "NBS LCIRC $1");

package/dist/flavors/plateau/index.js

@@ -20,11 +20,17 @@ function buildRules() {
     rule("edition_part", () => str("第").then(digits.then(str("."), digits).as("edition"), str("版")));
     rule("edition_latin", () => digits.then(str("."), digits).as("edition"));
     rule("edition", () => space.then(rules["edition_part"].or(rules["edition_latin"])));
+    // MLIT's volume label after the edition: 本編 (main volume) or
+    // 本編＋付録 (main volume with appendix). ASCII or full-width (U+3000)
+    // space; ASCII "+" or full-width "＋" (U+FF0B), which the builder
+    // normalizes to "＋".
+    rule("volume_sep", () => str(" ").or(str("　")));
+    rule("volume", () => rules["volume_sep"].then(str("本編").then(str("＋").or(str("+")).then(str("付録")).maybe()).as("volume")));
     rule("annex_supplement", () => space.then(str("Annex")).then(space, match("[A-Z]").as("annex_letter")));
     rule("handbook", () => str("PLATEAU")
         .then(space, rules["doc_type"], space, rules["number"])
         .then(rules["annex"].maybe())
-        .then(rules["edition"].maybe()));
+        .then(rules["edition"].then(rules["volume"].maybe()).maybe()));
     rule("identifier", () => rules["handbook"]
         .then(rules["annex_supplement"])
         .as("base")
@@ -42,14 +48,21 @@ function plateauClass(kind) {
             number: { type: "integer" },
             annex: { type: "integer" },
             edition: { type: "string" },
+            // The volume label MLIT prints after the edition: "本編" (the main
+            // volume alone) or "本編＋付録" (main volume and appendix, one
+            // PDF). A nil volume means the publication has no volume label:
+            // "#00 第5.0版" does not subsume "#00 第5.0版 本編＋付録".
+            volume: { type: "string" },
         });
-        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "edition", to: "edition" }, { wire: "annex", to: "annex" });
+        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "edition", to: "edition" }, { wire: "annex", to: "annex" }, { wire: "volume", to: "volume" });
         render() {
             let result = `PLATEAU ${isHandbook ? "Handbook" : "Technical Report"} #${pad2(this.number)}`;
             if (this.annex !== undefined)
                 result += `-${this.annex}`;
             if (isHandbook && this.edition !== undefined)
                 result += ` 第${this.edition}版`;
+            if (this.volume !== undefined)
+                result += ` ${this.volume}`;
             return result;
         }
     }
@@ -91,6 +104,12 @@ export function plateauGrammarImplementation() {
             if (data["edition"] !== undefined && data["edition"] !== null && kind === "handbook") {
                 attrs["edition"] = String(data["edition"]);
             }
+            // The grammar reads a volume label only after an edition, on the
+            // Handbook; the builder normalizes the ASCII "+" to the
+            // full-width "＋" (MLIT prints full-width).
+            if (data["volume"] !== undefined && data["volume"] !== null && kind === "handbook") {
+                attrs["volume"] = String(data["volume"]).replaceAll("+", "＋");
+            }
             return new KIND_CLASSES[kind](attrs);
         },
     };

package/dist/pubid-urn/schemas/iho.js

@@ -15,6 +15,9 @@ export const ihoSchema = define("iho", (s) => {
     s.atom("part", "part");
     s.atom("part_edition", "parted");
     s.atom("part_year", "party");
+    s.atom("spec", "spec");
+    s.atom("spec_sub", "specsub");
+    s.atom("spec_variant", "specvar");
     s.atom("annex", "annex");
     s.atom("annex_edition", "anned");
     s.atom("annex_year", "annyear");

package/dist/pubid-urn/schemas/plateau.js

@@ -10,6 +10,7 @@ export const plateauSchema = define("plateau", (s) => {
     s.atom("publisher", "pub");
     s.atom("edition", "ed");
     s.atom("annex", "annex", "int");
+    s.atom("volume", "vol");
     s.type("pubid:plateau:annex", "annex", {
         core: [],
         atoms: [["letter", "letter"]],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pubid/pubid",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "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",
@@ -19,7 +19,7 @@
     "doc:api": "node scripts/api-reference.mjs"
   },
   "dependencies": {
-    "parsanol": "0.10.45",
+    "parsanol": "0.10.46",
     "yaml": "^2.5.0"
   },
   "devDependencies": {