@pubid/pubid 0.1.8 → 0.1.10

package/vendor/parg/w3c.json

@@ -0,0 +1 @@
+{"bindings":null,"version":"0.1.0","grammar":"PubidW3c","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Str":{"pattern":"W3C "}},{"Entity":{"atom":16}},{"Entity":{"atom":13}},{"Str":{"pattern":"DNOTE"}},{"Str":{"pattern":"NOTE"}},{"Str":{"pattern":"WD"}},{"Str":{"pattern":"CRD"}},{"Str":{"pattern":"CR"}},{"Str":{"pattern":"REC"}},{"Str":{"pattern":"PER"}},{"Str":{"pattern":"PR"}},{"Str":{"pattern":"SPSD"}},{"Str":{"pattern":"OBSL"}},{"Alternative":{"atoms":[3,4,5,6,7,8,9,10,11,12]}},{"Named":{"name":"type","atom":2}},{"Str":{"pattern":"-"}},{"Sequence":{"atoms":[14,15]}},{"Repetition":{"atom":1,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":22}},{"Entity":{"atom":20}},{"Re":{"pattern":"[\\x01-\\u{10ffff}]"}},{"Repetition":{"atom":19,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"rest","atom":21}},{"Sequence":{"atoms":[0,17,18]}}],"root":23},"bindings":[]}},"preprocess":{},"tables":{},"lint":{"order_warnings":["rule type_token: branches 4 and 5 are order-dependent (shared first bytes; ordered choice is decisive)","rule type_token: branches 7 and 8 are order-dependent (shared first bytes; ordered choice is decisive)"]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"W3C REC-html40-19981224","expect":{}},{"entry":"identifier","kind":"accept","input":"W3C NOTE-datetime-19980827","expect":{}},{"entry":"identifier","kind":"reject","input":"nonsense","expect":{}}],"docs":{},"source":"# Port of lib/pubid/w3c/parser.rb: split off the leading maturity token;\n# code/date boundary is builder-side by design. Token order matters for\n# shared prefixes (CRD before CR, PER before PR, DNOTE before NOTE).\n\ngrammar PubidW3c version \"0.1.0\" {\n  any_char = %x01-10FFFF\n  type_token = \"DNOTE\" / \"NOTE\" / \"WD\" / \"CRD\" / \"CR\" / \"REC\" / \"PER\" / \"PR\" / \"SPSD\" / \"OBSL\"\n  type_part = type_token as type \"-\"\n  rest = (1*any_char) as rest\n  identifier = \"W3C \" [type_part] rest\n  entry identifier: identifier\n\n  test {\n    accept \"W3C REC-html40-19981224\"\n    accept \"W3C NOTE-datetime-19980827\"\n    reject \"nonsense\"\n  }\n}\n","checksum":"sha256:6c6fcb039d92331a683c48e8654064500142c1467d262928107ee9321033f0d7"}

package/vendor/parg/xsf.json

@@ -0,0 +1 @@
+{"bindings":null,"version":"0.1.0","grammar":"PubidXsf","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Str":{"pattern":"XEP "}},{"Entity":{"atom":10}},{"Entity":{"atom":3}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Repetition":{"atom":2,"min":1,"max":null,"tag":"Repetition"}},{"Entity":{"atom":8}},{"Str":{"pattern":"README"}},{"Str":{"pattern":"xxxx"}},{"Alternative":{"atoms":[6,7]}},{"Alternative":{"atoms":[4,5]}},{"Named":{"name":"number","atom":9}},{"Sequence":{"atoms":[0,1]}}],"root":11},"bindings":[]}},"preprocess":{},"tables":{},"lint":{"order_warnings":[]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"XEP 0001","expect":{}},{"entry":"identifier","kind":"accept","input":"XEP README","expect":{}},{"entry":"identifier","kind":"reject","input":"nonsense","expect":{}}],"docs":{},"source":"# Port of lib/pubid/xsf/parser.rb: \"XEP NNNN\" plus the two named\n# documents (README, xxxx) in SPECIAL_NUMBERS.\n  grammar PubidXsf version \"0.1.0\" {\n  digit = %x30-39\n  special_number = \"README\" / \"xxxx\"\n  number = (1*digit / special_number) as number\n  identifier = \"XEP \" number\n  entry identifier: identifier\n\n  test {\n    accept \"XEP 0001\"\n    accept \"XEP README\"\n    reject \"nonsense\"\n  }\n}\n","checksum":"sha256:ee98d45eed7bfa9222911db413f58244568ed028ac0146d6ee2e7b486c87c1d9"}

package/dist/pg/runtime.d.ts

@@ -1,85 +0,0 @@
-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

@@ -1,170 +0,0 @@
-//! 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

@@ -1,20 +0,0 @@
-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

@@ -1,90 +0,0 @@
-//! 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");
-}