pubid 2.0.21 → 2.0.22

data/data/parg/iso.parg

@@ -11,6 +11,20 @@
 # below, whose captures carry the idf_ prefix so they never collide
 # with the ISO ones and can bind as scalars.
 #
+# 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.
+#
 # Edition 2 with typed model bindings: every capture the builder
 # consumes is bound. Supplement layers capture into position-scoped
 # names (supp_* on the first supplement, supp2_* on the second,
@@ -23,7 +37,7 @@
 
 use idf
 
-grammar PubidIso version "0.4.0" edition 2 {
+grammar PubidIso version "0.5.0" edition 2 {
 
   # ---- lexical (pubid/parser/common_parse_rules.rb + ISO override) ----
   digit = %x30-39
@@ -47,6 +61,7 @@ grammar PubidIso version "0.4.0" edition 2 {
   # inline the alt so the capture holds one scalar span) ----
   typed_stage_abbrev = alt from_table "typed_stages" column "abbr"
   supp_stage_abbrev = alt from_table "typed_stages_supplements" column "abbr"
+  ballot_stage_abbrev = alt from_table "typed_stages_ballots" column "abbr"
   directives_stage_abbrev = alt from_table "directives_typed_stages" column "abbr"
   directives_supp_stage_abbrev = alt from_table "directives_supplements_typed_stages" column "abbr"
   idf_stage_abbrev = alt from_table "idf_typed_stages" column "abbr"
@@ -395,6 +410,76 @@ grammar PubidIso version "0.4.0" edition 2 {
     )
   }
 
+  # ---- historic TYPE-first ballot faces (decode-to-modern) ----
+  ## The DAM-family ballot token in TYPE position. Captured under its
+  ## own name: the supplement tables' captures stay reserved for the
+  ## on-base layers, and the ballot's stage is the one the decode keeps.
+  ballot_type_with_stage = {
+    (
+      (alt from_table "typed_stages_ballots" column "abbr")
+    ) as ballot_type_with_stage
+  }
+  ## 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 ballot's stage comes from the TYPE token). Mirrors the three
+  ## supplement tails: a (glued or spaced) number with an optional
+  ## date, or a dot number.
+  ballot_stamp = {
+    slash supp_stage_abbrev
+    (
+      (
+        [space]
+        ((1*5digit)) as ballot_stamp_number
+        [
+          [space]
+          (
+            (colon / dash) [
+              (("19" / "20") 2*digit !digit [(dash 2*digit)] [(dash 2*digit)]) as ballot_stamp_date
+              / (("--" / "—")) as ballot_stamp_undated_marker
+            ]
+          )
+        ]
+      )
+      / ( dot (1*digit) 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.
+  ballot_supplement_identifier = {
+    prefix_with_copublishers
+    [space]
+    [slash]
+    ballot_type_with_stage
+    [ space ((1*digit)) as ballot_number space ]
+    [space]
+    [type_with_stage]
+    [space]
+    second_part
+    [ ballot_stamp ]
+  }
+  ## 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 supplement_base_no_third): that
+  ## rule ends in base_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.
+  ballot_space_supplement_identifier = {
+    [ (("Guide" / "GUIDE") as type_with_stage_fr) space ]
+    [prefix_with_copublishers]
+    [space]
+    [slash]
+    [type_with_stage]
+    [space]
+    second_part
+    space ballot_type_with_stage
+    [ space ((1*digit)) as ballot_number ]
+  }
+
   # ---- directives: "ISO/IEC DIR 1", "ISO/IEC JTC 1 DIR", supplements,
   # bundled "ISO/IEC DIR 1:2022 + IEC SUP:2022" ----
   directives_publisher_subgroup = ("JTC 1") as subgroup
@@ -609,7 +694,8 @@ grammar PubidIso version "0.4.0" edition 2 {
   }
 
   ## The ISO identifier root: common-text twin form first, then the
-  ## single spine.
+  ## single spine. The historic ballot faces go last — purely additive
+  ## branches (an input an earlier member parses keeps that parse).
   identifier = {
       bare_tc_document
     / nsb_iso_identifier
@@ -623,6 +709,8 @@ grammar PubidIso version "0.4.0" edition 2 {
     / supplement_identifier
     / joint_identifier
     / identifier_copublishers
+    / ballot_space_supplement_identifier
+    / ballot_supplement_identifier
   }
 
   entry identifier: identifier
@@ -712,6 +800,12 @@ bs3_undated_marker -> bs3_undated_marker (string)
     idf_supp_stage_iteration2 -> idf_supp_stage_iteration2 (string)
     idf_supp_date2 -> idf_supp_date2 (string)
     idf_supp_undated_marker -> idf_supp_undated_marker (string)
+    ballot_type_with_stage -> ballot_type_with_stage (string)
+    ballot_number -> ballot_number (string)
+    ballot_stamp_number -> ballot_stamp_number (string)
+    ballot_stamp_dot_number -> ballot_stamp_dot_number (string)
+    ballot_stamp_date -> ballot_stamp_date (string)
+    ballot_stamp_undated_marker -> ballot_stamp_undated_marker (string)
   }
 
   ## In-file grammar tests: run at compile time, embedded in the artifact,
@@ -728,9 +822,55 @@ bs3_undated_marker -> bs3_undated_marker (string)
     accept "ISO 5537|IDF 26"
     accept "ISO 4055/Amd 1:2021"
     accept "ISO/R 9:1962"
+    accept "ISO/IEC FDAM 1 14496-12:2004"
+    accept "ISO/PDAM 19973-2"
+    accept "ISO/IEC FPDAM 9075/1"
+    accept "ISO/IEC FPDAM 10373-6/Amd 9:2001"
+    accept "ISO/PDAM 19110:2005/Amd.1"
+    accept "ISO/IEC PDAM TR 9573-11/Amd.1"
+    accept "ISO/IEC PDAM 9541-1/Amd.4"
+    accept "ISO/IEC PDAM 2 10646:2012"
+    accept "ISO 15877-5:2009 FDAM 1"
+    accept "ISO 19776-2:2005/Am1:2006"
     reject "nonsense"
+    reject "ISO/PDAM"
+    reject "ISO/FDAM"
     example "ISO/IEC WD TS 25025" { publisher: "ISO" }
     example "JCGM 200:2008(F)" { publisher: "JCGM" }
+    example "ISO/IEC FDAM 1 14496-12:2004" {
+      ballot_type_with_stage: "FDAM"
+      ballot_number: "1"
+      number_with_part: "14496-12"
+      date: "2004"
+    }
+    example "ISO/PDAM 19973-2" {
+      ballot_type_with_stage: "PDAM"
+      number_with_part: "19973-2"
+    }
+    example "ISO/IEC FPDAM 10373-6/Amd 9:2001" {
+      ballot_type_with_stage: "FPDAM"
+      ballot_stamp_number: "9"
+      ballot_stamp_date: "2001"
+    }
+    example "ISO/PDAM 19110:2005/Amd.1" {
+      ballot_type_with_stage: "PDAM"
+      ballot_stamp_number: "1"
+    }
+    example "ISO/IEC FPDAM 9075/1" {
+      ballot_type_with_stage: "FPDAM"
+      number_with_part: "9075/1"
+    }
+    example "ISO 15877-5:2009 FDAM 1" {
+      ballot_type_with_stage: "FDAM"
+      ballot_number: "1"
+      number_with_part: "15877-5"
+      date: "2009"
+    }
+    example "ISO/IEC FDAM 19776-2:2005/Am1:2006" {
+      ballot_type_with_stage: "FDAM"
+      ballot_stamp_number: "1"
+      ballot_stamp_date: "2006"
+    }
   }
 }
 

data/data/parg/tables/iec_typed_stages.yaml

@@ -4,8 +4,10 @@
 - abbr: "ANW Amd"
 - abbr: "WD Amd"
 - abbr: "CDAM"
+- abbr: "PDAM"
 - abbr: "DAM"
 - abbr: "FDAM"
+- abbr: "FPDAM"
 - abbr: "PRF Amd"
 - abbr: "Amd"
 - abbr: "AMD"
@@ -14,6 +16,7 @@
 - abbr: "ANW Cor"
 - abbr: "WDCor"
 - abbr: "CDCor"
+- abbr: "CDCOR"
 - abbr: "DCOR"
 - abbr: "FDCOR"
 - abbr: "PRF Cor"

data/data/parg/tables/typed_stages_ballots.yaml

@@ -0,0 +1,6 @@
+- abbr: "PDAM"
+- abbr: "DAM"
+- abbr: "DAmd"
+- abbr: "FDAM"
+- abbr: "FDAmd"
+- abbr: "FPDAM"

data/data/parg/tables/typed_stages_supplements.yaml

@@ -44,6 +44,7 @@
 - abbr: "Amd"
 - abbr: "AMD"
 - abbr: "Amd."
+- abbr: "Am"
 - abbr: "PWI Cor"
 - abbr: "NP Cor"
 - abbr: "AWI Cor"

data/lib/pubid/iec/CLAUDE.md

@@ -39,7 +39,11 @@ These notes were part of the root `CLAUDE.md`. Read them before you change `lib/
 
   **Stage codes — the SSOT and what is settled.** The authoritative source for IEC stage abbreviations is committed in this repo: **`data/iec/stage-codes.md`** — the 52-row IEC/ISO stage-code correspondence table transcribed from IEC's official *IEC/ISO Harmonized APIs* documents (v0.0.8 2023-06, api-portal.iec.ch; v0.0.7 2021-05, iec-apiportal.apigee.io — the successors that replace the IEC Data Feeds), the legacy Data-Feeds field examples, and the IS-lifecycle ladder from `StageCodes_IS_v2.pdf` (2023-06). `www.iec.ch` itself is fully WAF-gated to non-browsers and the Wayback Machine holds no snapshots of its PDFs, so the extract — not the unreachable original — is the reference. **`Pubid::Iec.locate_stage` reads `TYPED_STAGES` only** (`lib/pubid/iec.rb`); `PROJECT_STAGES` (AFDIS, TCDV, PRVC…) are not queryable through it. Every one of metanorma-iec's 55 `STAGE_CODES` — the list quoted in pubid#237 — resolves, locked by `spec/pubid/iec/typed_stages_spec.rb` in the issue's own order; aliases are always **appended, never prepended**, so `abbr.first` (what renders) is unchanged. Notable rulings from that pass: **ADIS** is the legacy Data-Feeds spelling of AFDIS ("Approved for FDIS circulation", ISO_LEVEL 40.99) and is an alias on `cdv` (the typed stage claiming 40.99); **CDISH/CDPAS** are the 50.20 rows of the DISH/DPAS deliverables, not "committee draft ISH/PAS" (30.xx); **Reconciliation items recorded in the extract, deliberately not applied:** DELPUB sits at 99.60 there while the `is` ladder does not claim 99.60; CAN carries two codes (30.98 IS/TR/TS, 50.98 PAS/ISH/COR); the rows CDISH-table-siblings DECDISH/MERGED/SPLIT/PCC/PRVN/DEL/RPUB/TPUB and the per-deliverable translation/preparation families are not registered as typed-stage abbreviations.
 
-- **A standalone supplement is `==` its `from_hash(to_hash)` round trip — the cause was the synthetic base's stage, not the ivar swap.** A supplement written without its base (`IEC/FDAM 60038-1`, `IEC/DCOR 60038-1`, `IEC/DISH 60038-1`) gets a bare `Pubid::Iec::SingleIdentifier` base from `SupplementIdentifier#ensure_base`; `to_s`, `to_urn`, `to_hash` and `#hash` agreed on both paths, but `==` was false, so `#matches?` failed silently. **The hand-off blamed the swapped `@number`/`@part` ivars; that was wrong.** `EqualityIgnored#==` compares through `public_send`, so the reader overrides hid the swap from it. The real difference was `base.typed_stage`: `ensure_base` set an IS/undated `TypedStage` with no `code`, which `stage_to_kv` cannot serialize, so `from_hash` rebuilt the base with none. **Diagnose an `==` failure by diffing the attributes through their readers, recursively, before trusting a hypothesis about ivars.** The stage write is deleted (the JCGM "delete the write" shape); the one visible change is `root.to_s` of the synthetic base on the parse path (`IEC IS60038` → `IEC60038`, the value `from_hash` already gave). The ivar swap was cleaned up too, because it was a hazard: `ensure_base` now moves the supplement number from `@part` into `@number`, so the stored layout is what `from_hash` rebuilds, and the `#number`/`#part` overrides, `@supplement_number`, `@synthetic_base` and `mark_synthetic_standalone!` are gone. `synthetic_base?` reads `base.instance_of?(SingleIdentifier)`, so it also survives `#exclude`, which copies `base` into a new object (on `main` the copy lost the flag and rendered in attached form, `IEC IS60038/FDAM1`). **The move must not depend on which reader runs first**, and a first version got that wrong: it called `ensure_base` only in the slash-form branch of `Builder#build`, but the canonical spelling `IEC FDAM 60038-1` (what `to_s` prints) reaches a different grammar branch, so a fresh parse kept the grammar layout until something read `base` — `.number` answered `60038`, `to_mr_string` gave `iec.60038_amd.60038`, and `#exclude` (which copies through the readers) copied the unmoved numbers onto a base synthesised afterwards, rendering `IEC FDAM 60038-60038`. So `#number`/`#part` keep a thin override that only TRIGGERS the move (`settle_standalone_layout`: `ensure_base` when there is a `part` and no base) and then return the stored value, and `Iec::Identifier.parse` calls `ensure_base` on a top-level supplement so a fresh parse already stores the moved layout. Supplements without a part (consolidation members, `IEC/AMD 1:2017`) are untouched by either. Two renderings outside the fixture corpus move, both repairs: `exclude(:date)` of a standalone supplement keeps the standalone form, and `IEC FDAM 60038-1 (all parts)` renders as itself instead of `IEC IS60038/FDAM1 (all parts)`. One hazard is left, unreachable from the grammar: reading `part` on a hand-built supplement BEFORE its base is assigned synthesises a base and moves the number, so a later `base =` renders the moved number. **A second hand-off claim was also wrong: an equal `#hash` for two unequal objects is legal** (the rule is `a == b ⇒ a.hash == b.hash`); `compute_hash` does not read `base`, which is a collision, not a defect. Measured: all 12,331 pass-fixture ids are byte-identical in `to_s`, `to_urn`, `to_mr_string`, `root.number`, `to_hash` and class; all 32,949 `relaton-data-iec` `index-v2.yaml` rows keep `from_hash(row).to_hash == row` and `parse(from_hash(row).to_s) == from_hash(row)`, and none has a `pubid:iec:single-identifier` base, so **no index migration follows**. Locked by `spec/pubid/iec/standalone_supplement_round_trip_spec.rb` and by the six standalone fixtures now in `full/iec-pubid.txt`, which the whole-corpus `==` sweep in `spec/pubid/iec/root_number_spec.rb` covers. **Residue, deliberately unchanged:** the self-base form renders its number twice — `IEC/AMD 1:2017` → `IEC Amd 1-1:2017`, `IEC/FDAM 60038` → `IEC FDAM 60038-60038` — because `render_supplement_standalone` prints `base.number` and then the supplement's own number, which are the same value there. (hand-off: iec-standalone-supplement-ivar-swap.)
+- **A standalone supplement is `==` its `from_hash(to_hash)` round trip — the cause was the synthetic base's stage, not the ivar swap.** A supplement written without its base (`IEC/FDAM 60038-1`, `IEC/DCOR 60038-1`, `IEC/DISH 60038-1`) gets a bare `Pubid::Iec::SingleIdentifier` base from `SupplementIdentifier#ensure_base`; `to_s`, `to_urn`, `to_hash` and `#hash` agreed on both paths, but `==` was false, so `#matches?` failed silently. **The hand-off blamed the swapped `@number`/`@part` ivars; that was wrong.** `EqualityIgnored#==` compares through `public_send`, so the reader overrides hid the swap from it. The real difference was `base.typed_stage`: `ensure_base` set an IS/undated `TypedStage` with no `code`, which `stage_to_kv` cannot serialize, so `from_hash` rebuilt the base with none. **Diagnose an `==` failure by diffing the attributes through their readers, recursively, before trusting a hypothesis about ivars.** The stage write is deleted (the JCGM "delete the write" shape); the one visible change is `root.to_s` of the synthetic base on the parse path (`IEC IS60038` → `IEC60038`, the value `from_hash` already gave). The ivar swap was cleaned up too, because it was a hazard: `ensure_base` now moves the supplement number from `@part` into `@number`, so the stored layout is what `from_hash` rebuilds, and the `#number`/`#part` overrides, `@supplement_number`, `@synthetic_base` and `mark_synthetic_standalone!` are gone. `synthetic_base?` reads `base.instance_of?(SingleIdentifier)`, so it also survives `#exclude`, which copies `base` into a new object (on `main` the copy lost the flag and rendered in attached form, `IEC IS60038/FDAM1`). **The move must not depend on which reader runs first**, and a first version got that wrong: it called `ensure_base` only in the slash-form branch of `Builder#build`, but the canonical spelling `IEC FDAM 60038-1` (what `to_s` prints) reaches a different grammar branch, so a fresh parse kept the grammar layout until something read `base` — `.number` answered `60038`, `to_mr_string` gave `iec.60038_amd.60038`, and `#exclude` (which copies through the readers) copied the unmoved numbers onto a base synthesised afterwards, rendering `IEC FDAM 60038-60038`. So `#number`/`#part` keep a thin override that only TRIGGERS the move (`settle_standalone_layout`: `ensure_base` when there is a `part` and no base) and then return the stored value, and `Iec::Identifier.parse` calls `ensure_base` on a top-level supplement so a fresh parse already stores the moved layout. Supplements without a part (consolidation members, `IEC/AMD 1:2017`) are untouched by either. Two renderings outside the fixture corpus move, both repairs: `exclude(:date)` of a standalone supplement keeps the standalone form, and `IEC FDAM 60038-1 (all parts)` renders as itself instead of `IEC IS60038/FDAM1 (all parts)`. One hazard is left, unreachable from the grammar: reading `part` on a hand-built supplement BEFORE its base is assigned synthesises a base and moves the number, so a later `base =` renders the moved number. **A second hand-off claim was also wrong: an equal `#hash` for two unequal objects is legal** (the rule is `a == b ⇒ a.hash == b.hash`); `compute_hash` does not read `base`, which is a collision, not a defect. Measured: all 12,331 pass-fixture ids are byte-identical in `to_s`, `to_urn`, `to_mr_string`, `root.number`, `to_hash` and class; all 32,949 `relaton-data-iec` `index-v2.yaml` rows keep `from_hash(row).to_hash == row` and `parse(from_hash(row).to_s) == from_hash(row)`, and none has a `pubid:iec:single-identifier` base, so **no index migration follows**. Locked by `spec/pubid/iec/standalone_supplement_round_trip_spec.rb` and by the six standalone fixtures now in `full/iec-pubid.txt`, which the whole-corpus `==` sweep in `spec/pubid/iec/root_number_spec.rb` covers. **Residue, deliberately unchanged:** the self-base form renders its number twice — `IEC/AMD 1:2017` → `IEC Amd 1-1:2017` — because `render_supplement_standalone` prints `base.number` and then the supplement's own number, which are the same value there. (hand-off: iec-standalone-supplement-ivar-swap.) **CORRECTED 2026-11-12 (owner ruling, reverses this bullet's identity):** the part-to-number move this bullet introduced is the DEFECT the legacy-decode bullet below removes. `IEC/FDAM 60038-1` is not "base 60038 with FDAM 1": the whole `60038-1` is the base designation. The equality machinery this bullet built (the stored layout `from_hash` rebuilds, the reader-triggered settle, `synthetic_base?` reading the class) is kept and holds on the corrected identity.
+
+- **The legacy prefix faces decode onto the modern identity (owner ruling 2026-11-12; evidence: `data/iec/legacy-notation.md`; reverses #693's resolution).** The old notation prints the stage token BEFORE the base designation — the JTC1 ballot faces `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`, and the IEC draft faces `IEC/DCOR 60038-1`, `IEC/DISH 60038-1`, `IEC CDISH 60050-191`. #693's model had resolved those by STEALING the designation's part for the supplement (`ensure_base` moved `@part` into `@number`), so the old face and the modern on-base face (`IEC 60038-1/FDAM 1`) disagreed on the same document's identity. The decode now: **the designation moves WHOLE onto the base** (number, part, subpart, and the date — old notation prints the base's year, and a draft supplement carries no publication date of its own), **the supplement's number defaults to 1** (the no-number rule: an unnumbered DAM/PDAM/FDAM/FPDAM/DCOR/DISH means Amendment/Corrigendum/Interpretation-Sheet 1), and **the base is a concrete `InternationalStandard`**, not the synthetic `SingleIdentifier` — that concreteness is what makes the legacy face hash-match (and equal) the modern parse: `parse("IEC/DCOR 60038-1") == parse("IEC 60038-1/DCOR 1")`. The render is the modern on-base slash face (`IEC 60038-1/FDAM1`), so the legacy face is not a spelling facet — it is decoded, IHO-style.
+  **Two grammar halves.** The DAM-family prefix faces (`DAM`/`PDAM`/`FDAM`/`FPDAM`, spelled literally in the rule so the typed_stages table stays put for them) raised on main; the new `legacy_supplement` rule in `pubid-grammar` captures `legacy_stage`, the optional `legacy_supplement_number` (N before the base), and the base designation — including the old slash-part spelling (`FPDAM 9075/1` = base 9075, part 1; captured as `legacy_base_number` + `legacy_base_part`, and ordered BEFORE the dash-part alternative because `number_with_part` also matches a bare "9075", which would have left the "/1" dangling). The rule sits ahead of `standalone_supplement` in the ordered choice so both the slash and space faces reach it, and its date rides with the designation. PDAM/FPDAM joined the `iec_typed_stages` table and `Amendment::TYPED_STAGES` (stage codes mirror ISO's entries: PDAM at the CD level, FPDAM at the FDIS level; the LEAD harmonized codes are the circulation slots 30.20/50.20 — ISO's 30.00/50.00 are CDAM's and FDAM's (type, leading code) URN keys). The non-DAM draft faces (DCOR, FDCOR, CDISH, DISH, and any typed standalone with a designation-shaped token) already parsed; they are corrected by `ensure_base`, so the two paths converge on one decode. **The discriminator between a legacy face and a true standalone is the PART:** a designation token (`60038-1`, `9075/1`) moves whole onto the base; a bare ordinal (`IEC/AMD 1:2017`) is the supplement's own number and keeps the synthetic self-base (`IEC Amd 1-1:2017`, unchanged). Under the JTC1 reading a bare number after a DAM-family token is a base designation (`IEC FDAM 60038` → `IEC 60038/FDAM1`), not a self-base mangle — that residue from the #693 bullet is gone.
+  **Measured by the replay gate, not the suite alone:** over all 26,838 full-fixture inputs, `to_s`/`to_urn`/`to_mr_string`/`to_hash`/class/`root.number` are byte-identical to the `main` baseline EXCEPT exactly the 6 #693-era standalone rows (both faces of FDAM/DCOR/DISH `60038-1`), which re-resolve to the corrected identities; 0 inputs stopped parsing; the prefix faces go raise→parse (12,491 full entries → 12,359 pass, fail steady at 132). #693's equality invariant (`parse == from_hash(to_hash)`) holds on every corrected identity. Locked by `spec/pubid/iec/standalone_supplement_round_trip_spec.rb` (rewritten: legacy faces decode and equal their modern parses, the self-base standalone keeps its form), `stage_separator_spec.rb`, `amendment_spec.rb`, `corrigendum_spec.rb`, `interpretation_sheet_spec.rb`, and the pass fixtures re-pinned by `validation:classify`. **Remaining gaps, deliberately open:** the dotted on-base `/Amd.1` spelling still raises in the IEC flavor (ISO accepts it), and the stamped prefix faces (`ISO/IEC FPDAM 10373-6/Amd 9:2001`, `ISO/IEC PDAM 9541-1/Amd.4`, `ISO/IEC FDAM 19776-2:2005/Am1:2006`, `ISO/IEC PDAM TR 9573-11/Amd.1`) stay raising — their on-base amendment stamps need the dotted/ISO stamp spellings the IEC flavor does not carry (gap 4 of the draft); the ISO-side agent owns that study.
 
 ## pubid-scheme URN (issue #670; gaps closed by #687)
 

data/lib/pubid/iec/builder.rb

@@ -57,6 +57,53 @@ module Pubid
       def build(parsed_hash)
         all_parts = parsed_hash.delete(:all_parts)
 
+        # 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, with data/iec/
+        # legacy-notation.md): 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: unnumbered DAM/PDAM/FDAM/FPDAM means Amendment 1).
+        # 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)`.
+        if parsed_hash[:legacy_stage]
+          supp = build_supplement(
+            type_with_stage: parsed_hash[:legacy_stage],
+            number_with_part: parsed_hash[:legacy_supplement_number] || "1",
+          )
+          base_hash = {}
+          {
+            publisher: :publisher,
+            legacy_base_number_with_part: :number_with_part,
+            date: :date,
+            undated_marker: :undated_marker,
+            edition: :edition,
+            languages: :languages,
+          }.each do |source, target|
+            base_hash[target] = parsed_hash[source] if parsed_hash[source]
+          end
+          # The grammar binds the legacy face's copublisher as a top-level
+          # scalar (legacy_copublisher) — the wasm binder scatters array
+          # bindings over the sibling list when a bare copublisher node
+          # rides a flat shape — so the builder attaches it here, in the
+          # same shape the parse path used to carry.
+          if parsed_hash[:legacy_copublisher]
+            base_hash[:copublishers] = [{ copublisher: parsed_hash[:legacy_copublisher] }]
+          end
+          # The slash-part designation ("9075/1") captured number and part
+          # separately; they go on straight as the plain strings the retyped
+          # attributes are, not through cast (which has no :part type).
+          base = build(base_hash)
+          base.number = parsed_hash[:legacy_base_number].to_s if parsed_hash[:legacy_base_number]
+          base.part = parsed_hash[:legacy_base_part].to_s if parsed_hash[:legacy_base_part]
+          return apply_fragment_notation(wrap_with_supplement(base, supp),
+                                         parsed_hash)
+        end
+
         # Second supplement layer (/AMD1:2018/COR1:2019): build the
         # first-supplement form, then wrap the second supplement around
         # it.

data/lib/pubid/iec/identifiers/amendment.rb

@@ -54,6 +54,25 @@ module Pubid
             name: "Committee Draft Amendment",
             harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
           ),
+          # The JTC1 ladder's pre-DAM ballot face (zero IEC-only record usage
+          # — the DAM family rides on joint work only; see
+          # data/iec/legacy-notation.md). Stage codes mirror the ISO flavor's
+          # entry for the same letter: PDAM sits at the CD level (30.xx).
+          # The LEAD harmonized code is the circulation slot (30.20
+          # "circulated as CD"), not ISO's 30.00 — the URN writes
+          # stage-{harmonized_stages.first} and parses it back by
+          # (type, leading code), which CDAM (30.00) already claims; see
+          # spec/pubid/iec/pnw_stage_spec.rb.
+          Pubid::Components::TypedStage.new(
+            code: :pdam,
+            stage_code: :cd,
+            type_code: :amd,
+            abbr: ["PDAM"],
+            short_abbr: nil,
+            long_abbr: nil,
+            name: "Proposed Draft Amendment",
+            harmonized_stages: %w[30.20 30.00 30.60 30.92 30.93 30.98 30.99],
+          ),
           Pubid::Components::TypedStage.new(
             code: :damd,
             stage_code: :damd,
@@ -74,6 +93,21 @@ module Pubid
             name: "Final Draft Amendment",
             harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
           ),
+          # The JTC1 ladder's pre-FDAM ballot face (same provenance as PDAM
+          # above): FPDAM mirrors the ISO flavor's entry, at the FDIS level
+          # (50.xx). Its LEAD harmonized code is the circulation slot
+          # (50.20), not ISO's 50.00, which FDAM already claims as its
+          # (type, leading code) URN key.
+          Pubid::Components::TypedStage.new(
+            code: :fpdam,
+            stage_code: :fdamd,
+            type_code: :amd,
+            abbr: ["FPDAM"],
+            short_abbr: nil,
+            long_abbr: nil,
+            name: "Final Proposed Draft Amendment",
+            harmonized_stages: %w[50.20 50.00 50.60 50.92 50.98 50.99],
+          ),
           Pubid::Components::TypedStage.new(
             code: :pubamd,
             stage_code: :published,

data/lib/pubid/iec/identifiers/corrigendum.rb

@@ -44,7 +44,12 @@ module Pubid
             code: :cdcor,
             stage_code: :cd,
             type_code: :cor,
-            abbr: ["CDCor"],
+            # "CDCOR" is the all-caps spelling the attached-supplement
+            # renderer emits (abbr.first.upcase) when a legacy prefix face
+            # decodes onto a CDCor draft ("IEC/CDCor 60038-1" renders
+            # "IEC 60038-1/CDCOR1"); appended as an alias so the canonical
+            # render re-parses. abbr.first stays "CDCor" (spelling-only).
+            abbr: ["CDCor", "CDCOR"],
             short_abbr: "CDCor",
             long_abbr: "CD Cor",
             name: "Committee Draft Corrigendum",

data/lib/pubid/iec/supplement_identifier.rb

@@ -4,6 +4,11 @@ module Pubid
   module Iec
     # Identifier that represents a supplement to a base identifier.
     class SupplementIdentifier < SingleIdentifier
+      # The supplement number a legacy standalone face implies when its
+      # type token carries none ("IEC/DCOR 60038-1" is Corrigendum 1 of
+      # 60038-1); the owner's no-number rule.
+      LEGACY_STANDALONE_SUPPLEMENT_NUMBER = "1"
+
       attribute :base, Identifier, polymorphic: true
 
       # Serialize the supplemented document under "base". The supplement's own
@@ -22,8 +27,9 @@ module Pubid
         # (e.g. a bare "+AMD1:2008" nested in a consolidation): a fake doc whose
         # number equals the supplement's own. It renders nothing and the getter
         # recreates it identically on load, so don't persist it. A standalone
-        # supplement ("IEC/FDAM 60038-1") instead moves the real base number into
-        # the synthetic base (base.number != own number), which must be kept.
+        # supplement in the legacy prefix face ("IEC/DCOR 60038-1") instead
+        # holds the real base designation (base.number != own number), which
+        # must be kept.
         return if model.synthetic_base? && base.number.to_s == model.number.to_s
 
         doc.add_child(Lutaml::KeyValue::DataModel::Element.new("base",
@@ -45,13 +51,14 @@ module Pubid
         @base || ensure_base
       end
 
-      # A standalone supplement holds the grammar's layout (base number in
-      # `number`, supplement number in `part`) until #ensure_base moves it.
-      # Not every construction path goes through one builder branch ("IEC FDAM
-      # 60038-1" does not, nor a hand-built Amendment), so these readers make
-      # the move before they answer: the result never depends on which reader
-      # ran first, and #exclude, which copies through the readers, copies the
-      # moved layout. They only TRIGGER the move; they return the stored value.
+      # A standalone supplement written in the legacy prefix face holds the
+      # grammar's layout (the whole base designation on itself) until
+      # #ensure_base moves it. Not every construction path goes through one
+      # builder branch ("IEC DCOR 60038-1" reaches the typed branch, a
+      # hand-built Amendment none), so these readers make the move before
+      # they answer: the result never depends on which reader ran first, and
+      # #exclude, which copies through the readers, copies the moved layout.
+      # They only TRIGGER the move; they return the stored value.
       def number
         settle_standalone_layout
         super
@@ -81,14 +88,27 @@ module Pubid
 
       # Synthesise the base of a supplement that names none, and return it.
       #
-      # A standalone supplement ("IEC/FDAM 60038-1") arrives from the grammar
-      # with the BASE number in `number` and the SUPPLEMENT number in `part`.
-      # This moves the base number onto a bare SingleIdentifier base and stores
-      # the supplement number in `number`, so the attributes hold what they
-      # mean — the layout `from_hash` rebuilds from the serialized hash. A
-      # supplement with no part (a bare "+AMD1:2008" in a consolidation,
-      # "IEC/AMD 1:2017") gets a self-base whose number equals its own; its
-      # `number` is left as it is.
+      # A standalone supplement written in the legacy prefix face ("IEC/DCOR
+      # 60038-1", "IEC/DISH 60038-1") arrives from the grammar with the BASE
+      # designation stored on itself — the base number in `number`, the base
+      # part (and subpart) in `part`/`subpart`. That layout is the grammar's
+      # bound shape, not the identity: the face names a supplement OF that
+      # designation, so the designation moves WHOLE onto a concrete
+      # InternationalStandard base (publisher, copublishers and the date go
+      # with it — old notation prints the base's year, and a draft
+      # supplement carries no publication date of its own) and the
+      # supplement keeps a number of its own, defaulting to 1 — the
+      # no-number rule (an unnumbered draft face means
+      # Amendment/Corrigendum/Interpretation-Sheet 1; owner ruling
+      # 2026-11-12, reversing #693's part-to-number move, which stole the
+      # base's part for the supplement). The concrete base is what makes the
+      # decode hash-match (and equal) the modern on-base parse of the same
+      # document: `parse("IEC/DCOR 60038-1") == parse("IEC 60038-1/DCOR1")`.
+      #
+      # A supplement with no part (a true standalone like "IEC/AMD 1:2017",
+      # or a bare "+AMD1:2008" in a consolidation) keeps its own number and
+      # gets a synthetic self-base whose number equals it; its date stays
+      # its own.
       #
       # The base deliberately gets NO typed_stage. A stage without a code is
       # not serialized, so `from_hash` cannot restore one, and a stage set
@@ -102,15 +122,22 @@ module Pubid
         @ensuring_base = true
         return nil unless publisher && (@number || @part)
 
-        base = SingleIdentifier.new
-        base.publisher = publisher
-        base.number = @number if @number
-        base.subpart = @subpart if @subpart
-        base.date = date if date
-
         if @part
-          @number = @part
+          base = Identifiers::InternationalStandard.new
+          base.publisher = publisher
+          base.copublishers = copublishers if copublishers&.any?
+          base.number = @number
+          base.part = @part
+          base.subpart = @subpart if @subpart
+          base.date = date if date
+          @number = LEGACY_STANDALONE_SUPPLEMENT_NUMBER
           @part = nil
+          @date = nil
+        else
+          base = SingleIdentifier.new
+          base.publisher = publisher
+          base.number = @number if @number
+          base.date = date if date
         end
 
         @base = base
@@ -122,7 +149,10 @@ module Pubid
       # from_hash) synthesised for a standalone supplement; a real attached
       # base is always a concrete type (InternationalStandard, SheetIdentifier
       # …). Read from the base itself, so it survives #exclude, which copies
-      # `base` into a new object.
+      # `base` into a new object. A legacy prefix face's designation moves
+      # onto a CONCRETE InternationalStandard instead (see #ensure_base), so
+      # it renders in the attached, modern form and hash-matches the modern
+      # on-base parse of the same document.
       def synthetic_base?
         base.instance_of?(::Pubid::Iec::SingleIdentifier)
       end

data/lib/pubid/iho/CLAUDE.md

@@ -234,4 +234,5 @@ component with its own edition/year right after it (`sup-`, `part-`,
 `parted-`, `appendix-`, `appsub-`, `vol-`, `issue-` …). Case is preserved
 (`part-A`); the yearbook year is a volume (`vol-2024`, no `year-` value —
 the legacy `y.` marker stays decodable in the official URN parser, never
-emitted). The official `urn:mrn:iho:…` form stays on `#to_urn`.
+emitted). The positional `urn:iho:` form of `UrnGenerator` stays on
+`#to_urn` — pubid emits no `urn:mrn:iho:…` URN.

data/lib/pubid/iho/pubid_urn_schema.rb

@@ -17,7 +17,8 @@ module Pubid
     # `specvar-`). Letters stay case-preserved (`part-A`). The legacy
     # `y.` yearbook marker is decodable in the official URN parser, never
     # emitted here: a periodical has no `year-` atom value, its volume
-    # carries the year. The official urn:mrn:iho:… form stays on #to_urn.
+    # carries the year. The positional urn:iho:… form of UrnGenerator
+    # stays on #to_urn — pubid emits no urn:mrn:iho:… URN.
     PubidUrnSchema = Pubid::PubidUrn.define("iho") do
       atom "edition", "ed"
       atom "year", "year"

data/lib/pubid/iso/CLAUDE.md

@@ -158,3 +158,52 @@
   another reason — `DirectivesSupplement#supplement_publisher` is an
   `Iso::Components::Publisher` after `parse` and a `Pubid::Components::Publisher`
   after `from_hash` (11 supplements, 3 bundles).
+
+- **Historic TYPE-first ballot faces decode to the canonical on-base slash
+  form (owner ruling 2026-11-12, Option B — IHO-style decode-to-modern;
+  SSOT `data/iso/historic-schemes.md`).** 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`) used to raise; the
+  grammar (v0.5.0) gained two additive branches at the END of the
+  identifier alternation, so every face an existing member parses keeps its
+  exact parse (replayed: 15,307 fixture inputs and 213,414 stored
+  docidentifier faces byte-identical on `to_s`/`to_urn`/`to_hash`/
+  `to_mr_string`). What to know before editing either side:
+  - **The ballot token captures as `ballot_type_with_stage`** (table
+    `typed_stages_ballots`: PDAM, DAM, DAmd, FDAM, FDAmd, FPDAM), NOT as
+    `supp_type_with_stage` — a shared name would make the builder's
+    supplement-prefix peel wrap a second layer, while the stored twins keep
+    ONE level. `Builder#build_ballot_supplement` assembles the single
+    amendment layer and nests the rest (prefix, copublishers, the base's
+    own `type_with_stage` — the `TR` of `PDAM TR 9573-11` — and
+    `number_with_part`/`date`) as `:base`.
+  - **`ballot_number` is space-bounded on both sides** (mandatory trailing
+    space in the grammar group) so `PDAM 19973-2` cannot read 19973 as the
+    ballot number: with no second space the group backtracks and 19973
+    stays in `second_part`. This is the base-whole guard — the IEC-flavor
+    hazard (#693's `ensure_base`) of a base part migrating into the
+    supplement slot cannot happen here; the legacy slash-part of
+    `FPDAM 9075/1` stays a base part (`9075-1`).
+  - **The number precedence is TYPE token → on-base stamp → implied "1"**;
+    the stamp's number/date capture as `ballot_stamp_*` while its token
+    letters match UNCAPTURED (Option B keeps no spelling — the ballot's
+    stage is the TYPE token's). The implied 1 is the owner's no-number
+    rule, applied by `Builder#apply_implied_amendment_number` on EVERY
+    builder path (parse, URN, bundle members) for `Identifiers::Amendment`
+    with a nil number and `typed_stage.code` ∈ `{pdam, damd, fdamd, fpdam}`
+    — by `#code`, NOT `#stage_code` (PDAM's stage_code is `:cd`), and
+    `to_sym`-ed (the bound map delivers strings). The published stage
+    (abbr `Amd`) is out of scope: a numberless `ISO 1234/Amd` stays nil.
+  - **The `Am` spelling** joined `typed_stages_supplements` (after the Amd
+    entries) and the published stage's abbr list, so `/Am1:2006` parses as
+    an alias of `/Amd 1` through the EXISTING supplement branch and the
+    ballot stamp accepts it the same way. `detect_stage_format_long` now
+    treats an original spelling that is a prefix of the long abbr as the
+    long family, so `Am` renders canonical `Amd`; `AMD` still renders short
+    (facets keep spelling on render), `Amd.` still renders `Amd`.
+  - **The decode is one-way**: parse-in only, canonical renders emit the
+    on-base slash face, and a ballot face == its canonical spelling
+    (original_abbr is equality-ignored). Locked by
+    `spec/pubid/iso/ballot_face_decode_spec.rb` (all 13 SSOT anchors, the
+    no-number rule, base-whole guards, Am alias, stored-twin agreement, and
+    the website-face-vs-stored-face drift rows the SSOT §5 records).