pubid 2.0.21 → 2.0.23

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/doi_pfs/CLAUDE.md

@@ -0,0 +1,72 @@
+# DoiPfs — the PFS-compiled doi dev alias
+
+This flavor is **generated**, not hand-written: every file here is compiler
+output from `pubid-grammar`'s `definitions/doi.pfs` (pubid/pubid#706),
+reproduce with
+
+```bash
+cd ../pubid-grammar
+ruby scripts/pfs compile definitions/doi.pfs --as doi_pfs \
+  --parsanol-version <CI pin> --ruby-out ../pubid/lib
+cp artifacts/doi_pfs.json ../pubid/data/parg/doi_pfs.json
+```
+
+DO NOT EDIT these files by hand — a hand edit is silently overwritten by
+the next compile, and the grammar SSOT is the definition, not this module
+(the `data/parg/doi_pfs.json` artifact's freshness envelope and the
+definition's source sha pin the lineage).
+
+## The coexistence semantics (read before touching anything)
+
+`doi_pfs` is the **dev-alias key** of the doi scheme: it registers beside
+the coded `Pubid::Doi` so the compiled pipeline can be proven against the
+coded flavor without cutover (cutover — replacing `doi` with the compiled
+flavor — is a separate, later decision).
+
+- **Wire tag**: the definition declares `tag: "pubid:doi:resource"` — the
+  SCHEME's canonical tag — so `to_hash` is byte-identical with the coded
+  flavor. `Resource.polymorphic_name` overrides the class-name-derived
+  tag for exactly this reason. Consequence: a GLOBAL `Pubid.from_hash` of
+  a doi_pfs hash resolves the coded class (one scheme, one `_type`, one
+  global resolution); the alias's own `DoiPfs::Identifier.from_hash`
+  routes the tag back to `DoiPfs::Identifiers::Resource` through its
+  `DOI_TYPE_MAP`.
+- **URN namespace**: the definition declares `urn.namespace: doi`, so the
+  generated `UrnGenerator` pins `urn_namespace` to `"doi"` and `to_urn`
+  is byte-identical (`"urn:doi"`). The pubid-scheme schema registers
+  under the FLAVOR key (`PubidUrn.define("doi_pfs")`) — never re-register
+  under `"doi"`, that would overwrite the coded flavor's registration.
+- **Routing**: `Pubid.parse` keeps routing `doi:`-faced strings to the
+  coded flavor (registry keys sort `"doi"` first; both flavors claim the
+  same prefixes). The alias is reached through `Pubid::DoiPfs.parse`.
+
+## The parity gate
+
+`spec/pubid/doi_pfs/parity_spec.rb` is the spike's whole point: over the
+full doi inventory (coded fixtures + corpus rows + aliases + constructed
+edge cases), both flavors must agree byte-for-byte on `to_s`, `to_hash`,
+`to_urn`, `to_mr_string`, `to_pubid_urn` and fail on the same inputs with
+`Pubid::Errors::ParseError`. Drift is a defect in the definition or the
+compiler — never relax an expectation here.
+
+Non-obvious inventory facts, learned the hard way:
+
+- The combined faces (`https://doi.org/doi:10.1000/182`) are rejected by
+  the CODED flavor too (the optional faces compose non-backtracking), so
+  they are negatives.
+- `Pubid.parse("10.1000/182")` routes to **UN** on main, pre-existing:
+  the bare `10.` form is not a doi prefix-owner claim at a token
+  boundary (`10.` followed by a digit), and un's token run accepts it.
+  Only the scheme-faced form routes to Doi.
+- The coded builder re-adds `"10."` to the registrar digits its grammar
+  captures; the doi.pfs pattern captures the whole `10.` face, so the
+  doi_pfs builder binds `prefix` directly. Model-level outputs are
+  identical; only the bound wire map differs (`prefix: "1000"` vs
+  `"10.1000"` in the artifact's corpus).
+
+## v1 boundaries
+
+Single-type schemes only, `kind: string` fields only, no free-standing
+`stages:`/`supplements:` sections, no semantic decode rules (the
+DAM-family problem) — see `pubid-grammar`'s `definitions/README.md` for
+the language reference and the fail-closed validation rules.

data/lib/pubid/doi_pfs/builder.rb

@@ -0,0 +1,18 @@
+  module Pubid
+    module DoiPfs
+      class Builder
+        def self.build(parsed_data)
+          new.build(parsed_data)
+        end
+
+        def build(data)
+          Identifiers::Resource.new(
+            prefix: data[:prefix],
+            suffix: data[:suffix],
+          )
+        end
+      end
+    end
+  end
+
+  Pubid::DoiPfs::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/doi_pfs/identifier.rb

@@ -0,0 +1,36 @@
+  module Pubid
+    module DoiPfs
+      class Identifier < ::Pubid::Identifier
+        attribute :prefix, :string
+        attribute :suffix, :string
+
+        DOI_TYPE_MAP = {
+          "pubid:doi:resource" => "Pubid::DoiPfs::Identifiers::Resource",
+        }.freeze
+
+        key_value do
+          map "_type", to: :_type, polymorphic_map: DOI_TYPE_MAP
+          map "prefix", to: :prefix
+          map "suffix", to: :suffix
+        end
+
+        PUBLISHER = "DOI".freeze
+
+        def self.parse(identifier)
+          unless identifier.is_a?(String)
+            raise Pubid::Errors::InvalidInputError,
+                  Pubid::INPUT_NOT_A_STRING_MESSAGE
+          end
+
+          if identifier.length > Pubid::MAX_INPUT_LENGTH
+            raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+          end
+
+          identifier = ::Pubid.utf8_input(identifier)
+
+          parsed = Pubid::Parg::Model.bound(:doi_pfs, identifier)
+          Builder.build(parsed)
+        end
+      end
+    end
+  end

data/lib/pubid/doi_pfs/identifiers/resource.rb

@@ -0,0 +1,31 @@
+  module Pubid
+    module DoiPfs
+      module Identifiers
+        # Concrete DOI identifier type (PFS type `resource`).
+        class Resource < Identifier
+          TYPED_STAGES = [
+            Pubid::Components::TypedStage.new(
+              code: :pubdoi,
+              stage_code: :published,
+              type_code: :doi,
+              abbr: ["DOI"],
+              name: "DOI",
+              harmonized_stages: [],
+            ),
+          ].freeze
+
+          def self.type
+            { key: :doi, web: :doi, title: "DOI", short: "DOI" }
+          end
+
+          # The scheme-canonical wire tag declared in the definition:
+          # to_hash stays byte-identical with the scheme's coded
+          # flavor, and this flavor's own from_hash routes the tag
+          # to this class.
+          def self.polymorphic_name
+            "pubid:doi:resource"
+          end
+        end
+      end
+    end
+  end

data/lib/pubid/doi_pfs/identifiers.rb

@@ -0,0 +1,7 @@
+module Pubid
+  module DoiPfs
+    module Identifiers
+      autoload :Resource, "#{__dir__}/identifiers/resource"
+    end
+  end
+end

data/lib/pubid/doi_pfs/parser.rb

@@ -0,0 +1,10 @@
+module Pubid
+  module DoiPfs
+    # PFS-generated parser shell. Parsing runs through the baked
+    # PARG artifact (data/parg/doi_pfs.json) via Pubid::Parg::Model.bound;
+    # the grammar source lives in pubid-grammar
+    # (grammars/doi_pfs.parg, compiled from definitions/doi.pfs).
+    class Parser
+    end
+  end
+end

data/lib/pubid/doi_pfs/pubid_urn_schema.rb

@@ -0,0 +1,15 @@
+  module Pubid
+    module DoiPfs
+      # The pubid-scheme URN schema, registered under the compiled
+      # flavor key. The definition's declared namespace
+      # ("doi") is the scheme's canonical
+      # namespace; identifiers carry the scheme's wire tag, so their
+      # pubid URNs encode through the scheme's own schema.
+      PubidUrnSchema = Pubid::PubidUrn.define("doi_pfs") do
+        atom "prefix", "prefix"
+        atom "suffix", "suffix"
+        type "pubid:doi_pfs:identifier", "id", core: []
+        type "pubid:doi_pfs:resource", "resource", core: []
+      end
+    end
+  end

data/lib/pubid/doi_pfs/renderer.rb

@@ -0,0 +1,10 @@
+module Pubid
+  module DoiPfs
+    # Human renderer, generated from the canonical template.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        "doi:#{@id.prefix}/#{@id.suffix}"
+      end
+    end
+  end
+end

data/lib/pubid/doi_pfs/urn_generator.rb

@@ -0,0 +1,12 @@
+module Pubid
+  module DoiPfs
+    # The official URN generator, pinned to the scheme's declared
+    # namespace ("doi") so to_urn stays
+    # scheme-canonical under the compiled flavor key.
+    class UrnGenerator < ::Pubid::UrnGenerator::Base
+      def urn_namespace
+        "doi"
+      end
+    end
+  end
+end

data/lib/pubid/doi_pfs.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+#
+# PFS-generated flavor — DO NOT EDIT BY HAND.
+# Source: definitions/doi.pfs (pfs:1) sha256:60abc3c403c61019d727ee44d9a72591c1549672451e6609a72d36189cae6340
+# Compiler: pubid/grammar/pfs 0.1.0 (baked with parsanol 1.3.126)
+# Regenerate: ruby scripts/pfs compile definitions/doi.pfs --as doi_pfs --ruby-out <dir>
+
+require "pubid"
+
+module Pubid
+  # Digital Object Identifier flavor, compiled from its PFS definition
+  # (pubid/pubid#706). A compiled flavor is a peer of the coded
+  # flavors: same registry, same input guards, same error
+  # namespace, same URN contracts.
+  module DoiPfs
+    extend Pubid::PrefixesSupport
+
+    PREFIXES = ["doi:", "DOI:", "10."].freeze
+
+    autoload :Builder, "#{__dir__}/doi_pfs/builder"
+    autoload :Identifier, "#{__dir__}/doi_pfs/identifier"
+    autoload :Identifiers, "#{__dir__}/doi_pfs/identifiers"
+    autoload :Parser, "#{__dir__}/doi_pfs/parser"
+    autoload :Renderer, "#{__dir__}/doi_pfs/renderer"
+    autoload :PubidUrnSchema, "#{__dir__}/doi_pfs/pubid_urn_schema"
+    autoload :UrnGenerator, "#{__dir__}/doi_pfs/urn_generator"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: DoiPfs::Renderer)
+
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map do |c| 
+        
+        Identifiers.const_get(c); rescue NameError; nil 
+        
+      end
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
+      end
+    end
+
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find do |s| 
+        s.abbr.any? do |a|
+          a.to_s.upcase == abbr_str
+        end
+      end
+    end
+  end
+end
+
+Pubid::Registry.register(:doi_pfs, Pubid::DoiPfs)

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"