@pubid/pubid 0.1.6 → 0.1.7

package/dist/flavors/ieee/index.js

@@ -895,12 +895,21 @@ class IeeeBuilder {
         });
     }
     buildIecIeeCopublished(parsed) {
-        const content = extractValue(parsed["content"]);
+        const contentRaw = extractValue(parsed["content"]);
         let copublishedNumber;
         let draftInfo;
         let iecYear;
         let dateInfo;
-        if (content !== undefined) {
+        let relationships;
+        if (contentRaw !== undefined) {
+            // A bare (unparenthesised) revision narrative printed after the code
+            // is the same relationship prose as the parenthetical form (C3
+            // ruling) — rewrite it into the parenthetical shape so both
+            // spellings collapse onto one canonical.
+            let content = contentRaw;
+            const bare = content.match(/^(.+?) (Revis(?:ion|on) (?:of|to) IEEE Std .+)$/);
+            if (bare !== null)
+                content = `${bare[1]} (${bare[2]})`;
             if (content.includes("IEC:")) {
                 copublishedNumber = content.split(" IEC:")[0]?.trim();
             }
@@ -923,10 +932,35 @@ class IeeeBuilder {
                 if (iecPart !== undefined)
                     iecYear = iecPart.split(" ")[0];
             }
+            // The parenthetical tail is classified, not swallowed (C3 ruling):
+            // a "(Revision of IEEE Std ...)" narrative is a relationship, not
+            // identity — it lands in `relationships` so the URN carries it as
+            // the rel. segment and the canonical human drops it; an "(MM/DD)"
+            // print date is non-identity and dropped; anything else keeps the
+            // historical date_info rendering.
             if (content.includes(" (")) {
                 const datePart = content.split(" (")[1];
                 if (datePart !== undefined && datePart.includes(")")) {
-                    dateInfo = datePart.split(")")[0];
+                    const tail = datePart.split(")")[0];
+                    const revision = tail !== undefined
+                        ? tail.match(/^Revis(?:ion|on) (?:of|to) IEEE Std (.+)$/)
+                        : null;
+                    if (tail !== undefined && revision !== null) {
+                        let related;
+                        try {
+                            related = ieeeParseSingle(revision[1]);
+                        }
+                        catch {
+                            related = { toHuman: () => revision[1] };
+                        }
+                        relationships = [new IeeeRelationship("revision_of", [related], [])];
+                    }
+                    else if (tail !== undefined && /^\d{2}\/\d{2}$/.test(tail)) {
+                        // print date — non-identity, dropped
+                    }
+                    else if (tail !== undefined) {
+                        dateInfo = tail;
+                    }
                 }
             }
         }
@@ -937,6 +971,8 @@ class IeeeBuilder {
             attrs["iec_year"] = iecYear;
         if (dateInfo !== undefined)
             attrs["date_info"] = dateInfo;
+        if (relationships !== undefined)
+            attrs["relationships"] = relationships;
         Object.assign(attrs, copublishedStructured(copublishedNumber));
         return new IecIeeeCopublishedClass(attrs);
     }

package/dist/flavors/ieee/model.js

@@ -474,10 +474,9 @@ export function renderIeeeBase(id) {
             result += `Rev${id.revision}`;
         if (draftObj !== undefined) {
             let printed = draftObj.render();
-            if (iecIeeOnly) {
-                printed = printed.split(", ")[0];
-            }
-            else if (id.publisher === "IEEE" && (id.draft_status ?? "") === "") {
+            // The draft designator carries its date on every lead
+            // (docs/IEEE-DRAFT-STAGES.md §3) — mirrors the ruby render fix.
+            if (id.publisher === "IEEE" && (id.draft_status ?? "") === "") {
                 // The long comma form for dated project drafts; the
                 // unapproved-draft keeps its pinned single-comma form.
                 printed = printed.replace(/, ([A-Z][a-z]+) (\d{4})$/, ", $1, $2");

package/dist/flavors/itu/grammar.js

@@ -61,7 +61,16 @@ function buildRules() {
     rule("attachment", () => space.then(str("attachment").as("attachment")));
     // "ITU-T Q.120-Q.139 (11/1988)" — one document covering a range.
     rule("range_end", () => dash.then(letter.repeat(1, 3).then(dot, digits).as("range_end")));
-    rule("part", () => dash.then(digits.as("part")));
+    rule("date_part", () => space.then(str("("), digits.as("month").then(str("/")).maybe(), digit.repeat(4, 4).as("year"), str(")")));
+    // A "-YYYYMM" approval date — the "200307" of "T-REC-T.4-200307-I" and
+    // "ITU-T T.4-200307". ITU's own edition suffix is short ("-5"), so six
+    // digits that read as a plausible year (19xx/20xx) and month (01-12) are
+    // the date, never a part. A six-digit run that fails either test
+    // ("-200313", "-180001") is still a part, as it was before.
+    rule("yyyymm_year", () => str("19").or(str("20")).then(digit.repeat(2, 2)));
+    rule("yyyymm_month", () => str("0").then(match("[1-9]")).or(str("1").then(match("[0-2]"))));
+    rule("yyyymm_shape", () => rules["yyyymm_year"].then(rules["yyyymm_month"], digit.absent()));
+    rule("part", () => dash.then(rules["yyyymm_shape"].absent(), digits.as("part")));
     rule("parts", () => rules["part"].repeat(0, Infinity).as("parts"));
     // Imp code first: the standard code needs digits, which "Imp712" lacks.
     rule("imp_code", () => str("Imp")
@@ -70,7 +79,21 @@ function buildRules() {
     rule("standard_code", () => rules["number"]
         .then(rules["series_suffix"].maybe(), rules["subseries"].maybe(), rules["parts"], rules["qualifier_glued"].maybe()));
     rule("code", () => rules["imp_code"].or(rules["standard_code"]));
-    rule("date_part", () => space.then(str("("), digits.as("month").then(str("/")).maybe(), digit.repeat(4, 4).as("year"), str(")")));
+    // The status letter that trails the date in a publication id — "I" (in
+    // force) or "S" (superseded). It names the state of the edition, not the
+    // edition, so it is parsed and dropped. "S" is also the Spanish language
+    // suffix, so it is a status ONLY in the full "T-REC-…" id, where ITU
+    // always writes one; after an "ITU-T …-YYYYMM" print form only "I" is,
+    // and "-S" stays the language ("ITU-T Z.100-199911-S").
+    rule("id_status", () => dash.then(match("[IS]"), match("[A-Za-z0-9]").absent()));
+    rule("print_id_status", () => dash.then(str("I"), match("[A-Za-z0-9]").absent()));
+    rule("yyyymm_date", () => dash.then(rules["yyyymm_year"].as("year"), rules["yyyymm_month"].as("month"), digit.absent()));
+    rule("id_date", () => rules["yyyymm_date"].then(rules["print_id_status"].maybe()));
+    // Either date spelling of a Recommendation.
+    rule("document_date", () => rules["date_part"].or(rules["id_date"]));
+    // "ITU-T REC T.4", "ITU-T REC-T.4" — the redundant type word of ITU's
+    // own URLs. Not captured: a Recommendation is the default type.
+    rule("rec_word", () => str("REC").then(space.or(dash)));
     // "(V14)" plus the bare spellings "V2", "v10", "v.1" — all
     // normalise to the parenthesised form on render.
     rule("version_part", () => space.then(str("(V")
@@ -103,9 +126,9 @@ function buildRules() {
         .then(digits.then(dot.then(digits).repeat(0, Infinity)).as("supplement_number")));
     rule("supplement_date", () => space.then(str("("), digits.as("supplement_month").then(str("/")).maybe(), digit.repeat(4, 4).as("supplement_year"), str(")")));
     rule("base_with_series", () => rules["itu_prefix"]
-        .then(rules["sector"], space, rules["series"], dot, rules["code"], rules["range_end"].maybe(), rules["code_suffixes"], rules["combined_suffixes"].maybe(), rules["series_word"].maybe(), rules["attachment"].maybe(), rules["version_part"].maybe(), rules["date_part"].maybe()));
+        .then(rules["sector"], space, rules["rec_word"].maybe(), rules["series"], dot, rules["code"], rules["range_end"].maybe(), rules["code_suffixes"], rules["combined_suffixes"].maybe(), rules["series_word"].maybe(), rules["attachment"].maybe(), rules["version_part"].maybe(), rules["document_date"].maybe()));
     rule("base_without_series", () => rules["itu_prefix"]
-        .then(rules["sector"], space, rules["code"], rules["code_suffixes"], rules["attachment"].maybe(), rules["version_part"].maybe(), rules["date_part"].maybe()));
+        .then(rules["sector"], space, rules["code"], rules["code_suffixes"], rules["attachment"].maybe(), rules["version_part"].maybe(), rules["document_date"].maybe()));
     // Series-code documents ("EMC-5", "SEC-QKD"): 2+ letter mnemonic,
     // dash-joined number. The OB guard keeps "ITU-T OB-1" a clean parse
     // failure rather than an escaped ArgumentError.
@@ -165,16 +188,39 @@ function buildRules() {
     rule("supplement_identifier", () => rules["chained_supplement"]
         .or(rules["slash_chained_supplement"], rules["supplement_with_base"], rules["supplement_series_only"]));
     rule("with_series", () => rules["itu_prefix"]
-        .then(rules["sector"], space, rules["series"], dot, rules["code"], rules["range_end"].maybe(), rules["code_suffixes"], rules["combined_suffixes"].maybe(), rules["series_word"].maybe(), rules["attachment"].maybe(), rules["version_part"].maybe(), rules["date_part"].maybe(), rules["language"].maybe()));
+        .then(rules["sector"], space, rules["rec_word"].maybe(), rules["series"], dot, rules["code"], rules["range_end"].maybe(), rules["code_suffixes"], rules["combined_suffixes"].maybe(), rules["series_word"].maybe(), rules["attachment"].maybe(), rules["version_part"].maybe(), rules["document_date"].maybe(), rules["language"].maybe()));
     rule("without_series", () => rules["itu_prefix"]
-        .then(rules["sector"], space, rules["code"], rules["code_suffixes"], rules["attachment"].maybe(), rules["version_part"].maybe(), rules["date_part"].maybe(), rules["language"].maybe()));
+        .then(rules["sector"], space, rules["code"], rules["code_suffixes"], rules["attachment"].maybe(), rules["version_part"].maybe(), rules["document_date"].maybe(), rules["language"].maybe()));
     rule("ob_series", () => str("OB").as("series"));
     rule("ob_dot_body", () => dot.then(rules["number"]));
     rule("ob_no_body", () => space.then(str("No."), space, rules["number"]));
+    // "ITU OB 1000" — metanorma-itu's docidentifier ("Annex to ITU OB %").
+    // Accepted as an input spelling only; it renders "ITU OB No. 1000", the
+    // form ITU's own bulletin site uses.
+    rule("ob_bare_body", () => space.then(rules["number"]));
+    // The date as a bulletin prints it — "ITU-T OB.1096 - 15.III.2016": day,
+    // Roman month, year. The months are tried longest first, because PEG
+    // takes the first alternative that matches and "I" would otherwise win
+    // on "III"; "XIII" matches "XII", then fails on the required dot.
+    rule("roman_month", () => str("XII")
+        .or(str("XI"))
+        .or(str("X"))
+        .or(str("IX"))
+        .or(str("VIII"))
+        .or(str("VII"))
+        .or(str("VI"))
+        .or(str("V"))
+        .or(str("IV"))
+        .or(str("III"))
+        .or(str("II"))
+        .or(str("I")));
+    rule("ob_roman_date", () => str(" - ")
+        .then(digit.repeat(2, 2).as("day"), dot, rules["roman_month"].as("roman_month"), dot, digit.repeat(4, 4).as("year")));
+    rule("ob_date", () => rules["date_part"].or(rules["ob_roman_date"]));
     rule("ob_with_sector", () => rules["itu_prefix"]
-        .then(rules["sector"].then(space).maybe(), rules["ob_series"], rules["ob_dot_body"].or(rules["ob_no_body"]), rules["date_part"].maybe(), rules["language"].maybe()));
+        .then(rules["sector"].then(space).maybe(), rules["ob_series"], rules["ob_dot_body"].or(rules["ob_no_body"]).or(rules["ob_bare_body"]), rules["ob_date"].maybe(), rules["language"].maybe()));
     rule("ob_long_form", () => rules["itu_prefix"]
-        .then(rules["sector"].then(space).maybe(), str("Operational Bulletin").as("_op_bull"), space, str("No."), space, rules["number"], rules["date_part"].maybe(), rules["language"].maybe()));
+        .then(rules["sector"].then(space).maybe(), str("Operational Bulletin").as("_op_bull"), space, str("No."), space, rules["number"], rules["ob_date"].maybe(), rules["language"].maybe()));
     rule("special_publication", () => rules["ob_with_sector"].or(rules["ob_long_form"]));
     rule("annex_to_identifier", () => str("Annex to").then(space, rules["special_publication"].as("annex_to")));
     rule("handbook", () => rules["itu_prefix"]
@@ -191,8 +237,24 @@ function buildRules() {
     rule("common_text_twin", () => space
         .then(str("|"), space, match("[^|]").repeat(1, Infinity))
         .as("common_text_twin"));
+    // ITU's publication id — "T-REC-T.4-200307-I",
+    // "R-REC-BO.1130-5-202602-I": <sector>-REC-<number>[-<edition>]-<YYYYMM>
+    // [-<status>], the name ITU gives each edition in its URLs and PDF
+    // files. It builds the plain Recommendation it names and renders in the
+    // print form ("ITU-T T.4 (07/2003)"). The date is required: without it
+    // the string names no edition. No other rule starts with a bare sector
+    // letter, so the slot is free.
+    rule("publication_id", () => rules["sector"]
+        .then(dash, str("REC"), dash, rules["series"], dot, rules["code"], rules["yyyymm_date"], rules["id_status"].maybe(), rules["language"].maybe()));
+    // The Radio Regulations — "ITU-R RR", "ITU-R RR (2020)", and the URL
+    // spelling "ITU-R RR-2020". Always ITU-R. The trailing any.absent? is
+    // load-bearing: PEG ordered choice never re-enters the alternation once
+    // an alternative succeeds, so a partial match on "ITU-R RR.1" must fail
+    // here and fall through to with_series.
+    rule("radio_regulations", () => rules["itu_prefix"]
+        .then(str("R").as("sector"), space, str("RR").as("radio_regulations"), rules["date_part"].or(dash.then(digit.repeat(4, 4).as("year"))).maybe(), rules["language"].maybe(), match(".").absent()));
     rule("identifier", () => rules["annex_to_identifier"]
-        .or(rules["special_publication"], rules["supplement_identifier"], rules["annex_identifier"], rules["appendix_identifier"], rules["report_identifier"], rules["handbook"], rules["numeric_question"], rules["letter_question"], rules["with_series"], rules["contribution"], rules["series_code_identifier"], rules["without_series"]));
+        .or(rules["special_publication"], rules["supplement_identifier"], rules["annex_identifier"], rules["appendix_identifier"], rules["report_identifier"], rules["handbook"], rules["numeric_question"], rules["letter_question"], rules["radio_regulations"], rules["with_series"], rules["contribution"], rules["series_code_identifier"], rules["without_series"], rules["publication_id"]));
     rule("root", () => rules["identifier"]
         .then(rules["common_text_twin"])
         .or(rules["identifier"]));

package/dist/flavors/itu/index.js

@@ -1,7 +1,7 @@
 import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
 import { PubidDate } from "../../model/component.js";
 import { ituGrammar, normalizeWhitespaceItu } from "./grammar.js";
-import { ITU_CLASSES, ITU_LANGUAGES, ItuCode, ItuDesignation, } from "./model.js";
+import { ITU_CLASSES, ITU_LANGUAGES, ItuCode, ItuDesignation, ItuSpecialPublication, } from "./model.js";
 /**
  * Port of lib/pubid/itu/builder.rb — the exact dispatch order:
  * annex_to → annex_number → appendix_number → OB/_op_bull →
@@ -43,6 +43,9 @@ class ItuBuilder {
         if (tree["appendix_number"] !== undefined) {
             return this.withTwin(this.buildAppendixOfRecommendation(tree), twin);
         }
+        if (tree["radio_regulations"] !== undefined) {
+            return this.withTwin(this.buildRadioRegulations(tree), twin);
+        }
         if ((s(tree["series"]) === "OB" && tree["series_dash"] === undefined) || tree["_op_bull"] !== undefined) {
             return this.withTwin(this.buildSpecialPublication(tree), twin);
         }
@@ -98,17 +101,34 @@ class ItuBuilder {
         });
     }
     buildDate(tree) {
-        return new PubidDate({ year: s(tree["year"]), month: s(tree["month"]) });
+        // The Roman month of a bulletin date ("15.III.2016") is stored as the
+        // two-digit month every other ITU date uses; the day marks the spelling.
+        const roman = s(tree["roman_month"]);
+        const month = roman !== undefined
+            ? (ItuSpecialPublication.ROMAN_MONTHS.indexOf(roman) + 1).toString().padStart(2, "0")
+            : s(tree["month"]);
+        return new PubidDate({ year: s(tree["year"]), month, day: s(tree["day"]) });
     }
-    /** OB is cross-bureau — the sector of legacy strings is dropped. */
+    /** OB keeps the sector of the TSB spelling ("ITU-T OB.1096") — it is a
+     * spelling, not identity (ItuSpecialPublication ignores it in ==). */
     buildSpecialPublication(tree) {
         return new ITU_CLASSES["special_publication"]({
+            sector: s(tree["sector"]),
             series: "OB",
             code: tree["number"] !== undefined ? this.buildCode(tree) : undefined,
             date: tree["year"] !== undefined ? this.buildDate(tree) : undefined,
             language: normLanguage(tree["language"]),
         });
     }
+    /** "ITU-R RR (2020)" — the series carries the whole designation. */
+    buildRadioRegulations(tree) {
+        return new ITU_CLASSES["radio_regulations"]({
+            sector: s(tree["sector"]),
+            series: "RR",
+            date: tree["year"] !== undefined ? this.buildDate(tree) : undefined,
+            language: normLanguage(tree["language"]),
+        });
+    }
     buildAnnexTo(inner) {
         const data = flatten(inner);
         const base = this.buildSpecialPublication(data);

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

@@ -78,6 +78,13 @@ export declare class ItuHandbook extends ItuIdentifier {
     renderBase(): string;
 }
 export declare class ItuSpecialPublication extends ItuIdentifier {
+    static polymorphicName: string;
+    static mappings: FieldMapping[];
+    static ROMAN_MONTHS: string[];
+    renderBase(): string;
+    private renderObDate;
+}
+export declare class ItuRadioRegulations extends ItuIdentifier {
     static polymorphicName: string;
     static mappings: FieldMapping[];
     renderBase(): string;
@@ -169,6 +176,7 @@ export declare const ITU_CLASSES: {
     readonly report: typeof ItuReport;
     readonly handbook: typeof ItuHandbook;
     readonly special_publication: typeof ItuSpecialPublication;
+    readonly radio_regulations: typeof ItuRadioRegulations;
     readonly contribution: typeof ItuContribution;
     readonly question: typeof ItuQuestion;
     readonly combined: typeof ItuCombinedIdentifier;

package/dist/flavors/itu/model.js

@@ -218,6 +218,11 @@ const SUPPLEMENT_MAPPINGS = keyValue({ wire: "sector", to: "sector", toWire: (m)
 function urnDateSegment(id) {
     if (!(id.date instanceof PubidDate))
         return undefined;
+    // Only an Operational Bulletin's printed date carries a day
+    // ("15.III.2016"); it is in `==`, so it must reach the URN too.
+    if (id.date.day !== undefined && id.date.month !== undefined) {
+        return `${id.date.day}/${id.date.month}/${id.date.year}`;
+    }
     return id.date.month !== undefined ? `${id.date.month}/${id.date.year}` : id.date.year;
 }
 export class ItuUrnGenerator extends BaseUrnGenerator {
@@ -245,7 +250,14 @@ export class ItuUrnGenerator extends BaseUrnGenerator {
     }
     generateBaseUrn(id) {
         const parts = ["urn", "itu"];
-        parts.push(id.sector !== undefined ? id.sector.toLowerCase() : "itu");
+        // An Operational Bulletin is cross-bureau: its sector is a spelling,
+        // not identity (see ItuSpecialPublication), so it stays out of the URN.
+        if (id.sector !== undefined && !(id instanceof ItuSpecialPublication)) {
+            parts.push(id.sector.toLowerCase());
+        }
+        else {
+            parts.push("itu");
+        }
         // Reports number independently of Recommendations — the marker must
         // reach the URN or the two same-numbered documents collide.
         if (id instanceof ItuReport)
@@ -338,18 +350,43 @@ attachUrn(ItuHandbook);
 export class ItuSpecialPublication extends ItuIdentifier {
     static polymorphicName = "pubid:itu:special-publication";
     static mappings = STANDARD_MAPPINGS;
+    static ROMAN_MONTHS = ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XI", "XII"];
     renderBase() {
-        let result = `ITU ${this.series} No. ${this.code?.number ?? ""}`;
-        if (this.date instanceof PubidDate) {
-            result += this.date.month !== undefined
-                ? ` (${this.date.month.padStart(2, "0")}/${this.date.year})`
-                : ` (${this.date.year})`;
+        const number = this.code?.number ?? "";
+        const result = this.sector !== undefined
+            ? `ITU-${this.sector} ${this.series}.${number}`
+            : `ITU ${this.series} No. ${number}`;
+        return result + this.renderObDate();
+    }
+    renderObDate() {
+        if (!(this.date instanceof PubidDate))
+            return "";
+        if (this.date.day !== undefined && this.date.month !== undefined) {
+            const roman = ItuSpecialPublication.ROMAN_MONTHS[Number(this.date.month) - 1] ?? "";
+            return ` - ${this.date.day.padStart(2, "0")}.${roman}.${this.date.year}`;
         }
-        return result;
+        if (this.date.month !== undefined) {
+            return ` (${this.date.month.padStart(2, "0")}/${this.date.year})`;
+        }
+        return ` (${this.date.year})`;
     }
 }
 registerType(ItuSpecialPublication);
 attachUrn(ItuSpecialPublication);
+// The ITU Radio Regulations — the treaty text revised by each World
+// Radiocommunication Conference (hand-off itu-relaton-query-forms).
+// It has no document number: "RR" is the whole designation, stored as
+// the series; "ITU-R RR-2020" (URL spelling) normalizes to
+// "ITU-R RR (2020)".
+export class ItuRadioRegulations extends ItuIdentifier {
+    static polymorphicName = "pubid:itu:radio-regulations";
+    static mappings = STANDARD_MAPPINGS;
+    renderBase() {
+        return `ITU-${this.sector} ${this.series}${this.dateSuffix()}`;
+    }
+}
+registerType(ItuRadioRegulations);
+attachUrn(ItuRadioRegulations);
 export class ItuContribution extends ItuIdentifier {
     static polymorphicName = "pubid:itu:contribution";
     static mappings = STANDARD_MAPPINGS;
@@ -585,6 +622,7 @@ export const ITU_CLASSES = {
     report: ItuReport,
     handbook: ItuHandbook,
     special_publication: ItuSpecialPublication,
+    radio_regulations: ItuRadioRegulations,
     contribution: ItuContribution,
     question: ItuQuestion,
     combined: ItuCombinedIdentifier,

package/dist/pg/runtime.d.ts

@@ -0,0 +1,85 @@
+type PgArtifactJs = any;
+/** A field requirement from the binding-requirements schema. */
+export interface FieldRequirement {
+    type: string;
+    card: string;
+    preprocess?: string;
+}
+/** The binding-requirements schema record for one entry. */
+export interface EntrySchema {
+    root: string;
+    fields: Record<string, FieldRequirement>;
+    examples: {
+        input: string;
+        captures: Record<string, unknown>;
+    }[];
+}
+export type Schema = Record<string, EntrySchema>;
+/**
+ * A loaded, checksum-verified PG artifact with its schema.
+ * Construction throws when the checksum does not verify.
+ */
+export declare class PgRuntime {
+    readonly artifact: PgArtifactJs;
+    readonly schema: Schema;
+    readonly renderSpec: Record<string, RenderSegment[]>;
+    readonly entry: string;
+    readonly defaultEntry: string | null;
+    readonly envelope: Record<string, unknown>;
+    constructor(artifactJson: string, entry?: string);
+    /** Load an artifact JSON file and verify its checksum. */
+    static fromFile(path: string, entry?: string): PgRuntime;
+    /** The default artifacts directory (the pubid-grammar checkout). */
+    static artifactsDir(): string;
+    static load(grammar: string, entry?: string): PgRuntime;
+    /** Parse with the native wasm engine; returns the parsanol-shape tree. */
+    parseShape(input: string): unknown;
+    /** Apply the entry's bindings to a parsanol-shape tree. */
+    applyBindings(shape: unknown): Record<string, unknown>;
+    /** Parse and bind in one step. */
+    parseAndBind(input: string): Record<string, unknown> | null;
+    /**
+     * Schema-driven materialization: the schema (from the artifact, not
+     * hand-written model code) declares the fields a data model must
+     * implement; the bound captures populate a structurally-typed object.
+     * Card `1*`/`*` fields become arrays; `0..1` fields become nullable.
+     */
+    materialize(input: string): Materialized | null;
+    /** Render the identifier string from a bound map (F6). */
+    render(bound: Record<string, unknown>, variant?: string): string;
+    /** Parse, bind, and render in one step. */
+    renderString(input: string, variant?: string): string | null;
+    /** Evaluate a named derive spec against a bound map (F6). */
+    derive(name: string, bound: Record<string, unknown>): string;
+    /** Parse, bind, and evaluate a derive spec in one step. */
+    deriveString(input: string, name: string): string | null;
+    /** Run the artifact's embedded tests; empty list means green. */
+    runTests(): string[];
+}
+/** F6 v1 derive evaluator: {field} interpolates from the bound map. */
+export declare function deriveTemplate(derive: Record<string, string>, name: string, bound: Record<string, unknown>): string;
+export type RenderSegment = {
+    type: "field";
+    field: string;
+} | {
+    type: "literal";
+    text: string;
+} | {
+    type: "cond";
+    field: string;
+    then: RenderSegment[];
+};
+/** F6 v1 generic renderer: field / literal / cond-presence segments. */
+export declare function renderSegments(segments: RenderSegment[] | null, bound: Record<string, unknown>): string;
+/** A schema-materialized identifier: typed fields plus provenance. */
+export interface Materialized {
+    entry: string;
+    attributes: Record<string, unknown>;
+}
+/**
+ * Schema-driven materialization independent of any wasm handle —
+ * the same function the model layer will build on (T2 codegen emits the
+ * static view of exactly these fields).
+ */
+export declare function materializeFromSchema(schema: EntrySchema, bound: Record<string, unknown>): Materialized;
+export {};

package/dist/pg/runtime.js

@@ -0,0 +1,170 @@
+//! PG artifact runtime for TypeScript (TODO 12 / T1): checksum-verified
+//! artifact load, native wasm parse, bindings application, and
+//! schema-driven materialization. The engine is the vendored
+//! parsanol wasm package (PgArtifactJs, C9) — no grammar code lives in
+//! this repo; the artifact is the contract.
+import { createRequire } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+/** Walk up from this module to the package root (which holds package.json). */
+function packageRoot() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (; !existsSync(join(dir, "package.json")); dir = dirname(dir)) {
+        if (dir === dirname(dir))
+            throw new Error("package.json not found above pg runtime");
+    }
+    return dir;
+}
+// The vendored wasm glue is CommonJS and lives outside the compiled tree,
+// so resolve it against the package root at runtime.
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const wasm = require(join(packageRoot(), "vendor", "parsanol-wasm", "parsanol.js"));
+/**
+ * A loaded, checksum-verified PG artifact with its schema.
+ * Construction throws when the checksum does not verify.
+ */
+export class PgRuntime {
+    artifact;
+    schema;
+    renderSpec;
+    entry;
+    defaultEntry;
+    envelope;
+    constructor(artifactJson, entry) {
+        this.envelope = JSON.parse(artifactJson);
+        this.artifact = new wasm.PgArtifactJs(artifactJson);
+        this.schema = JSON.parse(this.artifact.schema());
+        this.renderSpec =
+            this.envelope["render"] ?? {};
+        // The compiler bakes default_entry: JSON key order is not preserved
+        // across engines, so the sorted entry list cannot rederive it.
+        this.defaultEntry =
+            JSON.parse(artifactJson)["default_entry"] ?? null;
+        this.entry = entry ?? this.defaultEntry ?? this.artifact.entryNames()[0];
+    }
+    /** Load an artifact JSON file and verify its checksum. */
+    static fromFile(path, entry) {
+        return new PgRuntime(readFileSync(path, "utf8"), entry);
+    }
+    /** The default artifacts directory (the pubid-grammar checkout). */
+    static artifactsDir() {
+        const env = process.env.PG_ARTIFACT_DIR;
+        if (env)
+            return env;
+        // pubid-grammar is a sibling checkout in the pubid workspace.
+        return join(packageRoot(), "..", "pubid-grammar", "artifacts");
+    }
+    static load(grammar, entry) {
+        return PgRuntime.fromFile(join(PgRuntime.artifactsDir(), `${grammar}.json`), entry);
+    }
+    /** Parse with the native wasm engine; returns the parsanol-shape tree. */
+    parseShape(input) {
+        return JSON.parse(this.artifact.parseShape(this.entry, input));
+    }
+    /** Apply the entry's bindings to a parsanol-shape tree. */
+    applyBindings(shape) {
+        return JSON.parse(this.artifact.applyBindings(this.entry, JSON.stringify(shape)));
+    }
+    /** Parse and bind in one step. */
+    parseAndBind(input) {
+        try {
+            return JSON.parse(this.artifact.parseAndBind(this.entry, input));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Schema-driven materialization: the schema (from the artifact, not
+     * hand-written model code) declares the fields a data model must
+     * implement; the bound captures populate a structurally-typed object.
+     * Card `1*`/`*` fields become arrays; `0..1` fields become nullable.
+     */
+    materialize(input) {
+        const bound = this.parseAndBind(input);
+        if (bound === null)
+            return null;
+        const schema = this.schema[this.entry];
+        if (!schema)
+            throw new Error(`artifact has no schema for entry ${this.entry}`);
+        return materializeFromSchema(schema, bound);
+    }
+    /** Render the identifier string from a bound map (F6). */
+    render(bound, variant = "default") {
+        return renderSegments((this.renderSpec[variant] ?? null), bound);
+    }
+    /** Parse, bind, and render in one step. */
+    renderString(input, variant = "default") {
+        const bound = this.parseAndBind(input);
+        return bound === null ? null : this.render(bound, variant);
+    }
+    /** Evaluate a named derive spec against a bound map (F6). */
+    derive(name, bound) {
+        return deriveTemplate((this.envelope["derive"] ?? {}), name, bound);
+    }
+    /** Parse, bind, and evaluate a derive spec in one step. */
+    deriveString(input, name) {
+        const bound = this.parseAndBind(input);
+        return bound === null ? null : this.derive(name, bound);
+    }
+    /** Run the artifact's embedded tests; empty list means green. */
+    runTests() {
+        return JSON.parse(this.artifact.runTests());
+    }
+}
+/** F6 v1 derive evaluator: {field} interpolates from the bound map. */
+export function deriveTemplate(derive, name, bound) {
+    const template = derive[name];
+    if (template === undefined)
+        throw new Error(`derive spec ${name} not declared`);
+    return template.replace(/\{(\w+)\}/g, (_, field) => {
+        const value = bound[field];
+        return value === undefined || value === null ? "" : String(value);
+    });
+}
+/** F6 v1 generic renderer: field / literal / cond-presence segments. */
+export function renderSegments(segments, bound) {
+    let out = "";
+    for (const segment of segments ?? []) {
+        if (segment.type === "field") {
+            const value = bound[segment.field];
+            out += value === undefined || value === null ? "" : String(value);
+        }
+        else if (segment.type === "literal") {
+            out += segment.text;
+        }
+        else if (segment.type === "cond") {
+            const value = bound[segment.field];
+            if (value !== undefined && value !== null)
+                out += renderSegments(segment.then, bound);
+        }
+    }
+    return out;
+}
+/**
+ * Schema-driven materialization independent of any wasm handle —
+ * the same function the model layer will build on (T2 codegen emits the
+ * static view of exactly these fields).
+ */
+export function materializeFromSchema(schema, bound) {
+    const attributes = {};
+    for (const [path, requirements] of Object.entries(schema.fields)) {
+        const leaf = path.includes("[]")
+            ? (path.split("].").pop() ?? path)
+            : path;
+        const value = bound[leaf];
+        if (requirements.card.endsWith("*")) {
+            const list = Array.isArray(value) ? value : value === undefined ? [] : [value];
+            attributes[leaf] = list;
+        }
+        else if (requirements.card === "0..1") {
+            attributes[leaf] = value === undefined ? null : value;
+        }
+        else {
+            attributes[leaf] = value;
+        }
+    }
+    return { entry: schema.root, attributes };
+}

package/dist/pg/suite.d.ts

@@ -0,0 +1,20 @@
+import { PgRuntime } from "./runtime.js";
+export type TestKind = "accept" | "reject" | "example";
+export interface SuiteTest {
+    kind: TestKind;
+    input: string;
+    expect?: Record<string, string>;
+}
+export interface Suite {
+    name: string;
+    entry?: string;
+    tests: SuiteTest[];
+}
+/** Parse one *.pgtest file (same grammar as Parsanol::PG::Suite#read_file). */
+export declare function readSuite(text: string, name: string): Suite;
+/** Load every *.pgtest file in a directory. */
+export declare function loadSuites(dir: string): Suite[];
+/** Run a suite against a runtime; returns failure descriptions. */
+export declare function runSuite(runtime: PgRuntime, suite: Suite): string[];
+/** The default suites directory (the pubid-grammar checkout). */
+export declare function suitesDir(): string;

package/dist/pg/suite.js

@@ -0,0 +1,90 @@
+//! T3: external *.pgtest suites run through the wasm runtime. The suite
+//! syntax matches the Ruby loader (Parsanol::PG::Suite): a
+//! `suite <name> [for <entry>] { ... }` header with accept / reject /
+//! example lines. Green means Ruby and TypeScript agree on the contract.
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { PgRuntime } from "./runtime.js";
+const LINE = /^\s*(accept|reject|example)\s+"((?:[^"\\]|\\.)*)"(?:\s*\{([^}]*)\})?\s*$/;
+const HEADER = /suite\s+(\w+)(?:\s+for\s+entry\s+(\w+))?\s*\{/;
+/** Parse one *.pgtest file (same grammar as Parsanol::PG::Suite#read_file). */
+export function readSuite(text, name) {
+    const body = text.replace(/^#[^\n]*\n/gm, "");
+    const header = HEADER.exec(body);
+    if (!header) {
+        throw new Error(`${name}: expected 'suite <name> [for <entry>] { ... }'`);
+    }
+    const tests = [];
+    for (const line of body.slice((header.index ?? 0) + header[0].length).split("\n")) {
+        if (line.trim() === "}")
+            break;
+        const match = LINE.exec(line);
+        if (!match)
+            continue;
+        const kind = match[1];
+        const rawInput = match[2] ?? "";
+        const input = JSON.parse(`"${rawInput}"`);
+        const expect = {};
+        if (match[3]) {
+            for (const pair of match[3].split(",")) {
+                const kv = /(\w+)\s*:\s*"((?:[^"\\]|\\.)*)"/.exec(pair);
+                const key = kv?.[1];
+                const raw = kv?.[2];
+                if (key && raw !== undefined)
+                    expect[key] = JSON.parse(`"${raw}"`);
+            }
+        }
+        tests.push(kind === "example" ? { kind, input, expect } : { kind, input });
+    }
+    const entry = header[2];
+    return entry === undefined
+        ? { name: header[1] ?? "suite", tests }
+        : { name: header[1] ?? "suite", entry, tests };
+}
+/** Load every *.pgtest file in a directory. */
+export function loadSuites(dir) {
+    return readdirSync(dir)
+        .filter((file) => file.endsWith(".pgtest"))
+        .map((file) => readSuite(readFileSync(join(dir, file), "utf8"), file.replace(/\.pgtest$/, "")));
+}
+/** Run a suite against a runtime; returns failure descriptions. */
+export function runSuite(runtime, suite) {
+    const failures = [];
+    const entry = suite.entry ?? runtime.entry;
+    for (const test of suite.tests) {
+        // The wasm runtime throws on parse failure; that is the reject signal.
+        let bound = null;
+        try {
+            bound = runtime.artifact.parseAndBind(entry, test.input);
+        }
+        catch {
+            bound = null;
+        }
+        if (test.kind === "reject") {
+            if (bound !== null) {
+                failures.push(`test ${JSON.stringify(test.input)}: expected the input to be rejected`);
+            }
+            continue;
+        }
+        if (bound === null) {
+            failures.push(`test ${JSON.stringify(test.input)}: expected the input to parse`);
+            continue;
+        }
+        if (test.kind === "example") {
+            const parsed = JSON.parse(bound);
+            for (const [key, value] of Object.entries(test.expect ?? {})) {
+                if (parsed[key] !== value) {
+                    failures.push(`test ${JSON.stringify(test.input)}: expected captures ${key}: ${JSON.stringify(value)}, got ${JSON.stringify(parsed[key])}`);
+                }
+            }
+        }
+    }
+    return failures;
+}
+/** The default suites directory (the pubid-grammar checkout). */
+export function suitesDir() {
+    const env = process.env.PG_SUITES_DIR;
+    if (env)
+        return env;
+    return join(PgRuntime.artifactsDir(), "..", "suites");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pubid/pubid",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "TypeScript PubID identifiers: resolution, normalization and canonical hashes for every identifier in the pubid-testsuite corpus (41 standards bodies), with a conformance runner mirroring the Ruby reference",
   "type": "module",
   "license": "MIT",