@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/gb/index.d.ts

@@ -0,0 +1,31 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+import { PubidDate, Publisher } from "../../model/component.js";
+export declare const gbGrammar: Grammar;
+export declare class GbIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    static flatScalarComponents: {
+        publisher: string;
+    };
+    static flatScalarFields: {
+        publisher: string;
+    };
+    readonly publisher: Publisher;
+    readonly mandate: string | undefined;
+    readonly number: string;
+    readonly part: string | undefined;
+    readonly date: PubidDate | undefined;
+    render(): string;
+}
+export declare class GbAllPartsIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static get attributes(): import("../../model/attribute.js").AttributeTable;
+    static get mappings(): never[];
+    readonly identifiers: GbIdentifier[];
+    render(): string;
+    toUrn(): string;
+}
+export declare function gbGrammarImplementation(): FlavorImplementation;

package/dist/flavors/gb/index.js

@@ -0,0 +1,159 @@
+import { match, str } from "../../grammar/engine.js";
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { extendAttributes, keyValue } from "../../model/attribute.js";
+import { BaseBuilder } from "../../model/builder.js";
+import { PubidDate, Publisher } from "../../model/component.js";
+/**
+ * Port of lib/pubid/gb/ on the unified model. The series code lives in
+ * the inherited `publisher` (a Publisher, flattened to its body scalar
+ * via the class's flat-scalar entry — the CEN precedent); mandate is
+ * split out of an inline /T|/Z; date flattens to `year` (shared rule).
+ * No Ruby urn_generator: the BASE template derives
+ * urn:gb:<publisher>:<number>[:-part][:year] with the publisher
+ * lowercased.
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const digits = match("[0-9]").repeat(1, Infinity);
+    rule("publisher_code", () => 
+    // Social-group form: "T/" then uppercase letters/digits.
+    (str("T/").then(match("[A-Z0-9]").repeat(1, Infinity))).as("publisher_code")
+        // Confidential national series: lowercase "n" is part of the code
+        // (PEG: before the uppercase-only branch, no backtracking).
+        .or((str("GBn").then(str("/T").or(str("/Z")).maybe())).as("publisher_code"))
+        // Standard form: 1-3 letters, optional slash-T-or-Z.
+        .or((match("[A-Z]")
+        .repeat(1, 3)
+        .then(str("/T").or(str("/Z")).maybe()).as("publisher_code"))));
+    rule("mandate_suffix", () => str("/").then(str("T").or(str("Z")).as("mandate")).maybe());
+    rule("number", () => digits.as("number"));
+    rule("part", () => str(".").then(digits.as("part")));
+    rule("year", () => str("-").or(str("—")).then(match("[0-9]").repeat(4, 4).as("year")).maybe());
+    rule("all_parts_flag", () => space.then(str("("), str("all parts"), str(")")).as("all_parts"));
+    rule("identifier", () => rules["publisher_code"]
+        .then(space)
+        .then(rules["mandate_suffix"])
+        .then(rules["number"])
+        .then(rules["part"].maybe())
+        .then(rules["year"])
+        .then(rules["all_parts_flag"].maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const gbGrammar = { rules: buildRules(), root: "root" };
+export class GbIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:gb:standard";
+    static attributes = extendAttributes(BaseIdentifier, {
+        publisher: { type: Publisher },
+        mandate: { type: "string" },
+        number: { type: "string" },
+        part: { type: "string" },
+    });
+    static mappings = keyValue({
+        wire: "publisher",
+        to: "publisher",
+        // The flat wire form is the Publisher's body scalar; rebuild the
+        // component on deserialize (lutaml coerces it on the Ruby side).
+        fromWire: (hash) => {
+            const value = hash["publisher"];
+            return typeof value === "string" ? new Publisher({ body: value }) : value;
+        },
+    }, { wire: "mandate", to: "mandate" }, { wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "date", to: "date" });
+    // GB's flat-scalar entry: the Publisher serializes as its body scalar.
+    static flatScalarComponents = { publisher: "publisher" };
+    static flatScalarFields = { publisher: "body" };
+    render() {
+        let code = this.publisher.body;
+        if (this.mandate !== undefined && !code.includes("/"))
+            code += `/${this.mandate}`;
+        let numberPortion = this.number;
+        if (this.part !== undefined)
+            numberPortion += `.${this.part}`;
+        if (this.date !== undefined && this.date.year !== undefined)
+            numberPortion += `-${this.date.year}`;
+        return `${code} ${numberPortion}`;
+    }
+}
+registerType(GbIdentifier);
+// The document a member names: without its part and its edition (the
+// attributes an all-parts reference ignores).
+function gbDocumentOf(member) {
+    const r = member;
+    return new GbIdentifier({
+        publisher: r["publisher"],
+        mandate: r["mandate"],
+        number: r["number"],
+    });
+}
+// "GB/T 5606 (all parts)" names every part of one document: the wrapper
+// holds the member identifiers (gem #433 - the mark is a class, not a
+// flag), renders the document plus the suffix, and URNs as the document.
+export class GbAllPartsIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:gb:all-parts";
+    static get attributes() {
+        return extendAttributes(BaseIdentifier, {
+            identifiers: { type: GbIdentifier, collection: true },
+        });
+    }
+    static get mappings() {
+        return [{ wire: "identifiers", to: "identifiers" }];
+    }
+    render() {
+        const first = this.identifiers[0];
+        return `${first === undefined ? "" : gbDocumentOf(first).render()} (all parts)`;
+    }
+    toUrn() {
+        const first = this.identifiers[0];
+        return gbDocumentOf(first).toUrn();
+    }
+}
+registerType(GbAllPartsIdentifier);
+class GbBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return GbIdentifier;
+    }
+    build(tree) {
+        const id = super.build(tree);
+        if (tree["all_parts"] === undefined)
+            return id;
+        // "(all parts)" wraps the document it parsed.
+        return new GbAllPartsIdentifier({
+            identifiers: [id],
+        });
+    }
+    cast(key, value) {
+        if (key === "publisher_code") {
+            // Split an inline /T or /Z mandate out of the code.
+            const code = String(value);
+            const m = /^(.*?)\/(T|Z)$/.exec(code);
+            return m
+                ? { publisher: new Publisher({ body: m[1] }), mandate: m[2] }
+                : { publisher: new Publisher({ body: code }) };
+        }
+        if (key === "year") {
+            return value === undefined || value === null ? null : { date: new PubidDate({ year: String(value) }) };
+        }
+        if (key === "all_parts") {
+            // Presence marker only: the wrapper carries the members.
+            return value;
+        }
+        return value;
+    }
+}
+export function gbGrammarImplementation() {
+    const builder = new GbBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(gbGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("GB: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import { Grammar } from "../../grammar/engine.js";
+export declare const gostGrammar: Grammar;

package/dist/flavors/gost/grammar.js

@@ -0,0 +1,46 @@
+import { match, ref, str } from "../../grammar/engine.js";
+/**
+ * Port of lib/pubid/gost/parser.rb — 1:1. Root: identifier.
+ *
+ * Captures: gost_word, scope_r (R/Р), prefix_text (copublisher/subtype
+ * as a raw string, split by the builder), raw (number+year digit runs),
+ * adopted_raw (the foreign id after "/"), adopted_reference_raw (the
+ * parenthesized harmonization list).
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    rule("dot", () => str("."));
+    rule("year_sep", () => str("-").or(str("—")).or(str("–")).then(space.maybe()));
+    rule("gost_word", () => str("GOST").or(str("ГОСТ")).as("gost_word").then(space));
+    rule("scope_r", () => match("R").or(match("Р")).as("scope_r").then(space));
+    rule("prefix_text", () => match("[A-ZА-Яa-zа-я/]")
+        .repeat(1, Infinity)
+        .then(space.then(match("[A-ZА-Яa-zа-я/]").repeat(1, Infinity)).repeat(0, Infinity))
+        .as("prefix_text")
+        .then(space));
+    rule("digits", () => match("[0-9]").repeat(1, Infinity));
+    rule("raw_body", () => ref(rules, "digits")
+        .then(ref(rules, "dot").or(ref(rules, "year_sep")).then(ref(rules, "digits")).repeat(0, Infinity))
+        .as("raw"));
+    rule("adopted_part", () => space.maybe().then(str("/")).then(match(".").repeat(1, Infinity).as("adopted_raw")));
+    rule("adopted_reference_part", () => space
+        .maybe()
+        .then(str("("))
+        .then(match("[^)]").repeat(1, Infinity).as("adopted_reference_raw"))
+        .then(str(")")));
+    rule("identifier", () => ref(rules, "gost_word")
+        .then(ref(rules, "scope_r").maybe())
+        .then(ref(rules, "prefix_text").maybe())
+        .then(ref(rules, "raw_body"))
+        .then(ref(rules, "adopted_part").maybe())
+        .then(ref(rules, "adopted_reference_part").maybe()));
+    return rules;
+}
+export const gostGrammar = {
+    rules: buildRules(),
+    root: "identifier",
+};

package/dist/flavors/gost/index.d.ts

@@ -0,0 +1,2 @@
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+export declare function gostGrammarImplementation(): FlavorImplementation;

package/dist/flavors/gost/index.js

@@ -0,0 +1,165 @@
+import { parseGrammar } from "../../grammar/engine.js";
+import { grammarImplementation } from "../index.js";
+import { gostGrammar } from "./grammar.js";
+import { PREFIX_ROUTES } from "./prefix_routes.js";
+import { ForeignReference, Harmonized, IdenticalAdoption, InterstateStandard, NationalStandard, } from "./model.js";
+const COPUBLISHER_MAP = {
+    "ИСО": "ISO", "МЭК": "IEC", "ЕН": "EN",
+    "ИСО/МЭК": "ISO/IEC", "МЭК/ИСО": "IEC/ISO",
+    "ИСО/ТУ": "ISO/TS", "ИСО/ТО": "ISO/TR",
+    "МЭК/ТУ": "IEC/TS", "МЭК/ТО": "IEC/TR",
+    "ИСО/МЭК/ТУ": "ISO/IEC/TS",
+};
+const SUBTYPE_MAP = {
+    "МФС": "ISP", "ТУ": "TS", "ТО": "TR",
+};
+const NUMBER_YEAR_SPLIT = /^(.+?)\s*[-—–]\s*(\d{2}|\d{4})$/;
+// The gem's try_each_flavor iterates Registry.flavor_names.sort; this
+// mirrors that order over the TS grammar registry (the still-unported
+// flavors are skipped). bsi's grammar parses bare ISO/IEC/IEEE
+// references (adopted inside BS documents) and returns the owning
+// flavor's identifier — that is what routes the joint "ISO/IEC …"
+// adoptions to the ISO flavor ahead of IEC.
+const FOREIGN_FALLBACK_ORDER = [
+    "tgpp", "ansi", "astm", "bipm",
+    "bsi",
+    "calconnect", "ccsds", "cen_cenelec", "cie", "doi", "easc", "ecma",
+    "etsi", "gb", "iala", "iana", "idf", "iec", "ieee", "ietf", "iho",
+    "isbn", "iso", "itu", "jcgm", "jis", "nist", "oasis", "ogc", "oiml",
+    "omg", "plateau", "un", "w3c", "xsf",
+];
+const str = (v) => {
+    if (v === undefined || v === null)
+        return undefined;
+    const s = Array.isArray(v) ? v.map(String).join("") : String(v);
+    return s.length > 0 ? s : undefined;
+};
+function flatten(tree) {
+    return Array.isArray(tree) ? Object.assign({}, ...tree) : tree;
+}
+function buildIdentifier(tree) {
+    return buildFrom(flatten(tree));
+}
+function buildFrom(d) {
+    const russian = d["scope_r"] !== undefined;
+    const [copublisher, subtype] = splitPrefix(str(d["prefix_text"]));
+    const [number, year] = splitNumberYear(str(d["raw"]));
+    const klass = (russian ? NationalStandard : InterstateStandard);
+    const base = new klass({
+        ...(copublisher !== undefined ? { copublisher } : {}),
+        ...(subtype !== undefined ? { subtype } : {}),
+        ...(number !== undefined ? { number } : {}),
+        ...(year !== undefined ? { year } : {}),
+    });
+    return withForeignAdoption(base, d);
+}
+function withForeignAdoption(base, d) {
+    return wrapHarmonized(wrapIdenticalAdoption(base, d), d);
+}
+function wrapIdenticalAdoption(base, d) {
+    const adoptedRaw = str(d["adopted_raw"]);
+    if (adoptedRaw === undefined)
+        return base;
+    const adopted = parseForeign(adoptedRaw);
+    const klass = IdenticalAdoption;
+    return new klass({ base, adopted });
+}
+function wrapHarmonized(base, d) {
+    const referenceRaw = str(d["adopted_reference_raw"]);
+    if (referenceRaw === undefined)
+        return base;
+    const adopted = referenceRaw
+        .split(",")
+        .map((s) => s.trim())
+        .map(normalizeForeign)
+        .map(adoptIdentifier);
+    const klass = Harmonized;
+    return new klass({ base, adoptedIdentifiers: adopted });
+}
+function adoptIdentifier(raw) {
+    return parseForeign(raw) ?? new ForeignReference({ raw });
+}
+function splitPrefix(text) {
+    if (text === undefined)
+        return [undefined, undefined];
+    const tokens = text.trim().split(/\s+/);
+    const copublisher = normalizeCopublisher(tokens[0]);
+    const subtype = tokens.length > 1 ? normalizeSubtype(tokens.slice(1).join(" ")) : undefined;
+    return [copublisher, subtype];
+}
+function normalizeCopublisher(raw) {
+    if (raw === undefined)
+        return undefined;
+    return COPUBLISHER_MAP[raw] ?? raw.toUpperCase();
+}
+function normalizeSubtype(raw) {
+    if (raw === undefined)
+        return undefined;
+    return SUBTYPE_MAP[raw] ?? raw;
+}
+// Longest keys first so "ИСО/МЭК" wins over "ИСО".
+function normalizeForeign(raw) {
+    for (const cyr of Object.keys(COPUBLISHER_MAP).sort((a, b) => b.length - a.length)) {
+        if (raw.startsWith(cyr + " ") || raw.startsWith(cyr + "/")) {
+            return COPUBLISHER_MAP[cyr] + raw.slice(cyr.length);
+        }
+    }
+    return raw;
+}
+function splitNumberYear(raw) {
+    if (raw === undefined)
+        return [undefined, undefined];
+    const m = NUMBER_YEAR_SPLIT.exec(raw);
+    if (m === null)
+        return [raw, undefined];
+    return [m[1], m[2]];
+}
+// The single flavor owning the longest matching prefix; undefined when
+// no prefix matches or the prefix is jointly owned (joint forms go
+// through the fallback loop).
+function prefixOwner(raw) {
+    let match;
+    for (const prefix of Object.keys(PREFIX_ROUTES)) {
+        if ((raw.startsWith(`${prefix} `) || raw === prefix) &&
+            (match === undefined || prefix.length > match.length)) {
+            match = prefix;
+        }
+    }
+    if (match === undefined)
+        return undefined;
+    const owners = PREFIX_ROUTES[match] ?? [];
+    return owners.length === 1 ? owners[0] : undefined;
+}
+function tryParse(flavor, raw) {
+    const impl = grammarImplementation(flavor);
+    if (impl === undefined)
+        return undefined;
+    try {
+        return impl.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseForeign(raw) {
+    const owner = prefixOwner(raw);
+    if (owner !== undefined) {
+        const parsed = tryParse(owner, raw);
+        if (parsed !== undefined)
+            return parsed;
+    }
+    for (const flavor of FOREIGN_FALLBACK_ORDER) {
+        const parsed = tryParse(flavor, raw);
+        if (parsed !== undefined)
+            return parsed;
+    }
+    return undefined;
+}
+export function gostGrammarImplementation() {
+    return {
+        parse(input) {
+            const tree = parseGrammar(gostGrammar, input.trim());
+            return buildIdentifier(tree);
+        },
+    };
+}

package/dist/flavors/gost/model.d.ts

@@ -0,0 +1,61 @@
+import { BaseIdentifier } from "../../model/identifier.js";
+import { type FieldMapping } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+/**
+ * Port of lib/pubid/gost: the five identifier classes
+ * (interstate/national standard, identical adoption, harmonized,
+ * foreign reference), the renderer and the URN generator.
+ *
+ * GOST shape: GOST [R ][<copublisher> ][<subtype> ]<number>[-<year>]
+ *             [/<adopted>][(<refs>)]
+ */
+export declare abstract class GostIdentifier extends BaseIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly copublisher: string | undefined;
+    readonly subtype: string | undefined;
+    readonly number: string | undefined;
+    readonly year: string | undefined;
+}
+declare class GostUrnGenerator extends BaseUrnGenerator<GostIdentifier> {
+    generate(): string;
+}
+export declare class InterstateStandard extends GostIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof GostUrnGenerator;
+    render(): string;
+}
+export declare class NationalStandard extends GostIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof GostUrnGenerator;
+    render(): string;
+}
+export declare class ForeignReference extends GostIdentifier {
+    static polymorphicName: string;
+    static get attributes(): import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly raw: string | undefined;
+    render(): string;
+}
+declare function delegatedWireFields(model: BaseIdentifier, hash: Record<string, unknown>): void;
+export declare class Harmonized extends GostIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof GostUrnGenerator;
+    static get attributes(): import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    static compactHash: typeof delegatedWireFields;
+    readonly base: GostIdentifier | undefined;
+    readonly adoptedIdentifiers: GostIdentifier[] | undefined;
+    render(): string;
+}
+export declare class IdenticalAdoption extends GostIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof GostUrnGenerator;
+    static get attributes(): import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    static compactHash: typeof delegatedWireFields;
+    readonly base: GostIdentifier | undefined;
+    readonly adopted: GostIdentifier | undefined;
+    render(): string;
+}
+export {};

package/dist/flavors/gost/model.js

@@ -0,0 +1,147 @@
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { keyValue, extendAttributes } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+/**
+ * Port of lib/pubid/gost: the five identifier classes
+ * (interstate/national standard, identical adoption, harmonized,
+ * foreign reference), the renderer and the URN generator.
+ *
+ * GOST shape: GOST [R ][<copublisher> ][<subtype> ]<number>[-<year>]
+ *             [/<adopted>][(<refs>)]
+ */
+export class GostIdentifier extends BaseIdentifier {
+    static attributes = extendAttributes(BaseIdentifier, {
+        copublisher: { type: "string" },
+        subtype: { type: "string" },
+        number: { type: "string" },
+        year: { type: "string" },
+    });
+    // publisher defaults to "GOST" but is deliberately NOT mapped: the
+    // Ruby class declares it without a key_value entry, so it never
+    // serializes (a default-equal scalar would drop anyway).
+    static mappings = keyValue({ wire: "copublisher", to: "copublisher" }, { wire: "subtype", to: "subtype" }, { wire: "number", to: "number" }, { wire: "year", to: "year" });
+}
+function renderStandard(id) {
+    const national = id instanceof NationalStandard;
+    return [
+        "GOST",
+        national ? " R" : "",
+        id.copublisher !== undefined ? ` ${id.copublisher}` : "",
+        id.subtype !== undefined ? ` ${id.subtype}` : "",
+        ` ${id.number ?? ""}`,
+        id.year !== undefined ? `-${id.year}` : "",
+    ].join("");
+}
+class GostUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        let id = this.identifier;
+        while (id instanceof Harmonized || id instanceof IdenticalAdoption) {
+            id = id.base;
+        }
+        if (!(id instanceof InterstateStandard) && !(id instanceof NationalStandard)) {
+            throw new Error(`Unknown GOST identifier class: ${id.constructor.name}`);
+        }
+        const parts = ["urn", "gost", "std"];
+        if (id instanceof NationalStandard)
+            parts.push("r");
+        if (id.number !== undefined)
+            parts.push(id.number);
+        if (id.year !== undefined)
+            parts.push(id.year);
+        return parts.join(":");
+    }
+}
+export class InterstateStandard extends GostIdentifier {
+    static polymorphicName = "pubid:gost:interstate-standard";
+    static urnGenerator = GostUrnGenerator;
+    render() {
+        return renderStandard(this);
+    }
+}
+export class NationalStandard extends GostIdentifier {
+    static polymorphicName = "pubid:gost:national-standard";
+    static urnGenerator = GostUrnGenerator;
+    render() {
+        return renderStandard(this);
+    }
+}
+export class ForeignReference extends GostIdentifier {
+    static polymorphicName = "pubid:gost:foreign-reference";
+    // raw is instance-only: never declared on the wire (the Ruby class
+    // declares the attribute without a key_value mapping).
+    static get attributes() {
+        return extendAttributes(GostIdentifier, { raw: { type: "string" } });
+    }
+    static mappings = [];
+    render() {
+        return this.raw ?? "";
+    }
+}
+// number/year/copublisher/subtype delegate to base (Ruby overrides the
+// getters); the delegated values ride along on the wire via the
+// compactHash hook.
+function delegatedWireFields(model, hash) {
+    const base = model.base;
+    if (base === undefined)
+        return;
+    if (base.number !== undefined)
+        hash["number"] = base.number;
+    if (base.year !== undefined)
+        hash["year"] = base.year;
+    if (base.copublisher !== undefined)
+        hash["copublisher"] = base.copublisher;
+    if (base.subtype !== undefined)
+        hash["subtype"] = base.subtype;
+}
+export class Harmonized extends GostIdentifier {
+    static polymorphicName = "pubid:gost:harmonized";
+    static urnGenerator = GostUrnGenerator;
+    static get attributes() {
+        return extendAttributes(GostIdentifier, {
+            base: { type: GostIdentifier },
+            adoptedIdentifiers: {
+                type: GostIdentifier,
+                collection: true,
+            },
+        });
+    }
+    static mappings = [
+        ...GostIdentifier.mappings,
+        { wire: "base", to: "base" },
+        { wire: "adopted_identifiers", to: "adoptedIdentifiers" },
+    ];
+    static compactHash = delegatedWireFields;
+    render() {
+        const base = this.base?.toHuman() ?? "";
+        const adopted = (this.adoptedIdentifiers ?? []).map((a) => a.toHuman()).join(", ");
+        return adopted === "" ? base : `${base} (${adopted})`;
+    }
+}
+export class IdenticalAdoption extends GostIdentifier {
+    static polymorphicName = "pubid:gost:identical-adoption";
+    static urnGenerator = GostUrnGenerator;
+    static get attributes() {
+        return extendAttributes(GostIdentifier, {
+            base: { type: GostIdentifier },
+            adopted: { type: GostIdentifier },
+        });
+    }
+    static mappings = [
+        ...GostIdentifier.mappings,
+        { wire: "base", to: "base" },
+        { wire: "adopted", to: "adopted" },
+    ];
+    static compactHash = delegatedWireFields;
+    render() {
+        return `${this.base?.toHuman() ?? ""}/${this.adopted?.toHuman() ?? ""}`;
+    }
+}
+for (const klass of [
+    InterstateStandard,
+    NationalStandard,
+    ForeignReference,
+    Harmonized,
+    IdenticalAdoption,
+]) {
+    registerType(klass);
+}

package/dist/flavors/gost/prefix_routes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * GENERATED from the Ruby gem (Pubid.prefix_flavors after
+ * eager_load_flavors!) — the prefix→flavors routing table. Regenerate
+ * from the pubid gem with:
+ *   bundle exec ruby -e 'require "pubid"; Pubid.eager_load_flavors!;
+ *     require "json"; puts JSON.pretty_generate(Pubid.prefix_flavors
+ *     .transform_values { |v| v.sort })'
+ * Do not edit by hand.
+ *
+ * Used by the gost flavor's foreign-adoption routing (prefix_owner in
+ * index.ts): the single flavor owning the longest matching prefix parses
+ * the adopted identifier; joint prefixes (ISO/IEC, ANSI/AMCA…) fall
+ * through to the sorted fallback loop.
+ */
+export declare const PREFIX_ROUTES: Record<string, string[]>;