@pubid/pubid 0.1.37 → 0.1.38

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.37",
+  "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",