@pubid/pubid 0.1.37 → 0.1.38

package/dist/flavors/ecma/index.js

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

package/dist/flavors/iec/grammar.js

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

package/dist/flavors/iec/index.js

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

package/dist/flavors/iec/model.js

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

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;
 }