ng-form-foundry-transformers 0.4.0 → 0.5.0

package/README.md

@@ -16,7 +16,7 @@ or a CLI just as easily.
 | `yang` | YANG model (via an engine) | RFC 7951 instance data | available |
 | `yaml` | YAML config (optionally a JSON Schema) | YAML (comments preserved) | available |
 | `json` | JSON config (optionally a JSON Schema) | JSON (indent preserved) | available |
-| `libconfig` | libconfig document (optionally a JSON Schema) | libconfig (comments **and scalar types** preserved) | **beta** — warns on first use |
+| `libconfig` | libconfig document (optionally a JSON Schema) | libconfig (comments **and scalar types** preserved) | available |
 
 The YAML and JSON transformers share the same format-agnostic form builders in
 `core` (`inferNodeGroup`, `jsonSchemaToNodeGroup`) — a JSON Schema is an *option*
@@ -169,12 +169,10 @@ const { schema, binding, initialValue } = jsonTransformer.toSchema(configText);
 const out = jsonTransformer.toSource({ ...initialValue, replicas: 5 }, binding);
 ```
 
-## libconfig transformer (beta)
+## libconfig transformer
 
 Edit a **libconfig document** — the `.cfg`/`.conf` format of srsRAN, OAI, and
 other C/C++ software using [libconfig](https://hyperrealm.github.io/libconfig/).
-**Beta**: it logs a one-time warning on first use; diff `toSource` output
-against the original before deploying a write-back.
 
 ```ts
 import { libconfigTransformer } from 'ng-form-foundry-transformers';
@@ -294,6 +292,23 @@ npm test        # node:test on the compiled output (no Python needed)
 
 ## Status
 
+`0.5.0` — the **libconfig transformer is stable**: the one-time beta warning
+is gone (and with it the `resetLibconfigBetaWarning` helper), and the format's
+guarantees and known limitations are documented in the transformers guide.
+Non-decimal integer literals (`0x`, `0b`, `0o`/`0q`) now set a `radix` display
+hint on the generated schema — the paired `ng-form-foundry` release renders
+those fields as hex/octal/binary editors, and the YAML transformer does the
+same for its hex and octal literals.
+
+`0.4.1` — libconfig hardening after a conformance battle test against the C
+library's own scanner, test corpus, and real srsRAN/OAI configs: `0q`/`0Q`
+octal, verbatim radix-prefix preservation on edits, sign accepted on decimal
+literals only, negative edits into hex/bin/oct slots emit decimal, exact
+round-trips for collections mixing safe and beyond-2^53 integers, `null`
+rejected instead of written as `true`, a 256-level nesting cap, strict `\x`
+escapes, `@include` legal in value positions, and modified read-only carries
+throw instead of corrupting.
+
 `0.4.0` — version-alignment release with the workspace (the paired
 `ng-form-foundry` 0.4.0 adds appearance-driven field layout); no transformer
 changes.

package/dist/core/schema.d.ts

@@ -32,6 +32,13 @@ export interface Leaf {
     min?: number;
     max?: number;
     multipleOf?: number;
+    /**
+     * Present the value in this base (16 hex, 8 octal, 2 binary) instead of
+     * decimal — set when the source document wrote the literal that way. Purely
+     * a display hint: the value itself stays a plain number (or, on a string
+     * leaf, the exact decimal-digit carry of an integer beyond ±2^53).
+     */
+    radix?: 2 | 8 | 16;
     /** The value may be `null` (JSON Schema `type: [T, 'null']`). */
     nullable?: boolean;
     /** Optional scalar whose presence is itself data (on/off toggle). */
@@ -47,6 +54,8 @@ export interface LeafList {
     label?: string;
     minItems?: number;
     maxItems?: number;
+    /** Present every item in this base — see {@link Leaf.radix}. */
+    radix?: 2 | 8 | 16;
 }
 export interface NodeGroup {
     kind: 'nodeGroup';

package/dist/index.d.ts

@@ -13,8 +13,8 @@
  *   - `json` — JSON config → form → JSON ({@link jsonTransformer}); same builders
  *              as `yaml`, indent preserved.
  *   - `libconfig` — libconfig document (srsRAN/OAI-style `.cfg`/`.conf`) → form →
- *              libconfig ({@link libconfigTransformer}); **BETA**, warns once on
- *              first use; comment- and type-preserving span splicing on revert.
+ *              libconfig ({@link libconfigTransformer}); comment- and
+ *              type-preserving span splicing on revert.
  *
  * Look transformers up at runtime through {@link TransformerRegistry}, or import
  * the one you need directly.

package/dist/index.js

@@ -14,8 +14,8 @@
  *   - `json` — JSON config → form → JSON ({@link jsonTransformer}); same builders
  *              as `yaml`, indent preserved.
  *   - `libconfig` — libconfig document (srsRAN/OAI-style `.cfg`/`.conf`) → form →
- *              libconfig ({@link libconfigTransformer}); **BETA**, warns once on
- *              first use; comment- and type-preserving span splicing on revert.
+ *              libconfig ({@link libconfigTransformer}); comment- and
+ *              type-preserving span splicing on revert.
  *
  * Look transformers up at runtime through {@link TransformerRegistry}, or import
  * the one you need directly.
@@ -41,4 +41,4 @@ __exportStar(require("./core"), exports);
 __exportStar(require("./transformers/yang"), exports);
 __exportStar(require("./transformers/yaml"), exports);
 __exportStar(require("./transformers/json"), exports);
-__exportStar(require("./transformers/libconfig"), exports); // BETA — warns once on first use
+__exportStar(require("./transformers/libconfig"), exports);

package/dist/transformers/libconfig/index.d.ts

@@ -1,2 +1,2 @@
-export { libconfigTransformer, resetLibconfigBetaWarning, type LibconfigBinding, type LibconfigOptions, } from './libconfig-transformer';
+export { libconfigTransformer, type LibconfigBinding, type LibconfigOptions, } from './libconfig-transformer';
 export { parseLibconfig, LibconfigParseError } from './parser';

package/dist/transformers/libconfig/index.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LibconfigParseError = exports.parseLibconfig = exports.resetLibconfigBetaWarning = exports.libconfigTransformer = void 0;
+exports.LibconfigParseError = exports.parseLibconfig = exports.libconfigTransformer = void 0;
 var libconfig_transformer_1 = require("./libconfig-transformer");
 Object.defineProperty(exports, "libconfigTransformer", { enumerable: true, get: function () { return libconfig_transformer_1.libconfigTransformer; } });
-Object.defineProperty(exports, "resetLibconfigBetaWarning", { enumerable: true, get: function () { return libconfig_transformer_1.resetLibconfigBetaWarning; } });
 var parser_1 = require("./parser");
 Object.defineProperty(exports, "parseLibconfig", { enumerable: true, get: function () { return parser_1.parseLibconfig; } });
 Object.defineProperty(exports, "LibconfigParseError", { enumerable: true, get: function () { return parser_1.LibconfigParseError; } });

package/dist/transformers/libconfig/libconfig-transformer.d.ts

@@ -1,5 +1,5 @@
 /**
- * A libconfig {@link Transformer} (BETA): turn a libconfig document
+ * A libconfig {@link Transformer}: turn a libconfig document
  * (srsRAN/OAI-style `.cfg`/`.conf`) into a form and write the edited value
  * back with comments, formatting, and — critically — scalar *types*
  * preserved (libconfig is statically typed; see {@link import('./revert')}).
@@ -47,8 +47,6 @@ export interface LibconfigBinding {
     source: string;
     root: CfgGroup;
 }
-/** Test seam: makes the one-time beta warning observable per test. */
-export declare function resetLibconfigBetaWarning(): void;
 export declare const libconfigTransformer: {
     id: string;
     toSchema(source: string, options?: LibconfigOptions): TransformResult<LibconfigBinding>;

package/dist/transformers/libconfig/libconfig-transformer.js

@@ -1,28 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.libconfigTransformer = void 0;
-exports.resetLibconfigBetaWarning = resetLibconfigBetaWarning;
 const thesaurus_1 = require("../../core/thesaurus");
 const json_schema_1 = require("../../core/json-schema");
 const parser_1 = require("./parser");
 const schema_1 = require("./schema");
 const revert_1 = require("./revert");
-let warnedBeta = false;
-function warnBeta() {
-    if (warnedBeta)
-        return;
-    warnedBeta = true;
-    console.warn('[ng-form-foundry-transformers] The libconfig transformer is a BETA feature. ' +
-        'Verify every write-back (diff toSource output against the original file) before deploying it.');
-}
-/** Test seam: makes the one-time beta warning observable per test. */
-function resetLibconfigBetaWarning() {
-    warnedBeta = false;
-}
 exports.libconfigTransformer = {
     id: 'libconfig',
     toSchema(source, options) {
-        warnBeta();
         const root = (0, parser_1.parseLibconfig)(source, { includes: options?.includes });
         const schema = options?.schema
             ? (0, json_schema_1.jsonSchemaToNodeGroup)(options.schema, options.rootName, options.schemaOptions)
@@ -32,7 +18,6 @@ exports.libconfigTransformer = {
         return { schema: labeled, binding: { source, root }, initialValue };
     },
     toSource(value, binding) {
-        warnBeta();
         return (0, revert_1.applyValueToSource)(binding.source, binding.root, value);
     },
 };

package/dist/transformers/libconfig/parser.d.ts

@@ -13,9 +13,13 @@
  * (https://hyperrealm.github.io/libconfig/libconfig_manual.html); the grammar
  * covers: groups `{}`, arrays `[]` (homogeneous scalars), lists `()`
  * (heterogeneous), settings `name = value;` / `name : value` with an optional
- * `;`/`,` terminator, int (decimal/hex/binary/octal), int64 (`L`/`LL`
+ * `;`/`,` terminator, int (decimal, `0x` hex, `0b` binary, `0o`/`0q` octal —
+ * a sign is legal on decimal only, as in the C scanner), int64 (`L`/`LL`
  * suffix), float, bool (case-insensitive), strings with escapes and adjacent
- * literal concatenation, `#`/`//`/`/* *​/` comments, and `@include` lines.
+ * literal concatenation, `#`/`//`/`/* *​/` comments, and `@include` lines
+ * (handled as trivia, so they are legal anywhere the C scanner accepts them).
+ * Nesting is capped at {@link MAX_DEPTH} levels so hostile documents fail
+ * with a parse error instead of exhausting the JS stack.
  */
 /** Half-open source range of a node, in code-unit offsets. */
 export interface Span {
@@ -29,6 +33,8 @@ export interface IntMeta {
     suffix: string;
     /** Hex/binary/octal digit count of the literal, for width-preserving edits. */
     digits: number;
+    /** Radix prefix verbatim (`0x`, `0B`, `0q`, …), empty for decimal. */
+    prefix: string;
 }
 export type CfgValue = CfgScalar | CfgGroup | CfgArray | CfgList;
 export interface CfgScalar {

package/dist/transformers/libconfig/parser.js

@@ -14,9 +14,13 @@
  * (https://hyperrealm.github.io/libconfig/libconfig_manual.html); the grammar
  * covers: groups `{}`, arrays `[]` (homogeneous scalars), lists `()`
  * (heterogeneous), settings `name = value;` / `name : value` with an optional
- * `;`/`,` terminator, int (decimal/hex/binary/octal), int64 (`L`/`LL`
+ * `;`/`,` terminator, int (decimal, `0x` hex, `0b` binary, `0o`/`0q` octal —
+ * a sign is legal on decimal only, as in the C scanner), int64 (`L`/`LL`
  * suffix), float, bool (case-insensitive), strings with escapes and adjacent
- * literal concatenation, `#`/`//`/`/* *​/` comments, and `@include` lines.
+ * literal concatenation, `#`/`//`/`/* *​/` comments, and `@include` lines
+ * (handled as trivia, so they are legal anywhere the C scanner accepts them).
+ * Nesting is capped at {@link MAX_DEPTH} levels so hostile documents fail
+ * with a parse error instead of exhausting the JS stack.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LibconfigParseError = void 0;
@@ -33,18 +37,22 @@ class LibconfigParseError extends Error {
 }
 exports.LibconfigParseError = LibconfigParseError;
 const NAME_RE = /^[A-Za-z*][-A-Za-z0-9_*.]*/;
-const INT_RE = /^[-+]?(0[xX][0-9A-Fa-f]+|0[bB][01]+|0[oO][0-7]+|[0-9]+)(LL?)?/;
+// Like the C scanner: octal is `0o` or `0q`, and only decimal takes a sign.
+const INT_RE = /^(0[xX][0-9A-Fa-f]+|0[bB][01]+|0[oOqQ][0-7]+|[-+]?[0-9]+)(LL?)?/;
 const FLOAT_RE = /^[-+]?(([0-9]*\.[0-9]+|[0-9]+\.[0-9]*)([eE][-+]?[0-9]+)?|[0-9]+[eE][-+]?[0-9]+)/;
 const BOOL_RE = /^(true|false)(?![-A-Za-z0-9_*.])/i;
 /** Parse a libconfig document into its root group (spans index into `source`). */
 function parseLibconfig(source, options) {
     return new Parser(source, options?.includes ?? 'reject').parseRoot();
 }
+/** Deepest legal value nesting — far past real configs, well inside JS stack. */
+const MAX_DEPTH = 256;
 class Parser {
     constructor(src, includes) {
         this.src = src;
         this.includes = includes;
         this.pos = 0;
+        this.depth = 0;
     }
     parseRoot() {
         const settings = this.parseSettings(undefined);
@@ -67,10 +75,6 @@ class Parser {
             }
             if (closer && this.src[this.pos] === closer)
                 return settings;
-            if (this.src[this.pos] === '@') {
-                this.handleInclude();
-                continue;
-            }
             settings.push(this.parseSetting(settings));
         }
     }
@@ -94,14 +98,21 @@ class Parser {
         return { name, span: { start, end: this.pos }, value };
     }
     parseValue() {
-        const c = this.src[this.pos];
-        if (c === '{')
-            return this.parseGroup();
-        if (c === '[')
-            return this.parseCollection('[', ']', 'array');
-        if (c === '(')
-            return this.parseCollection('(', ')', 'list');
-        return this.parseScalar();
+        if (++this.depth > MAX_DEPTH)
+            this.fail(`nesting deeper than ${MAX_DEPTH} levels`);
+        try {
+            const c = this.src[this.pos];
+            if (c === '{')
+                return this.parseGroup();
+            if (c === '[')
+                return this.parseCollection('[', ']', 'array');
+            if (c === '(')
+                return this.parseCollection('(', ')', 'list');
+            return this.parseScalar();
+        }
+        finally {
+            this.depth--;
+        }
     }
     parseGroup() {
         const start = this.pos++;
@@ -181,15 +192,16 @@ class Parser {
         return this.fail('expected a value');
     }
     intScalar(lexeme, span) {
-        const sign = lexeme[0] === '-' ? '-' : '';
-        const unsigned = lexeme.replace(/^[-+]/, '');
-        const suffix = /LL?$/i.exec(unsigned)?.[0] ?? '';
-        const body = suffix ? unsigned.slice(0, -suffix.length) : unsigned;
-        const prefix = body.slice(0, 2).toLowerCase();
-        const radix = prefix === '0x' ? 16 : prefix === '0b' ? 2 : prefix === '0o' ? 8 : 10;
-        const digits = radix === 10 ? body : body.slice(2);
-        const big = BigInt(sign + (radix === 10 ? digits : body.slice(0, 2) + digits));
-        const meta = { radix, suffix, digits: digits.length };
+        const suffix = /LL?$/i.exec(lexeme)?.[0] ?? '';
+        const body = suffix ? lexeme.slice(0, -suffix.length) : lexeme;
+        const prefix = /^0[xXbBoOqQ]/.test(body) ? body.slice(0, 2) : '';
+        const p = prefix.toLowerCase();
+        const radix = p === '0x' ? 16 : p === '0b' ? 2 : p === '' ? 10 : 8;
+        const digits = prefix ? body.slice(2) : body.replace(/^[-+]/, '');
+        const sign = body[0] === '-' ? '-' : '';
+        // `0q`/`0O` normalize to a prefix BigInt understands; decimal keeps its sign.
+        const big = prefix ? BigInt((radix === 8 ? '0o' : p) + digits) : BigInt(sign + digits);
+        const meta = { radix, suffix, digits: digits.length, prefix };
         // Values past 2^53 ride as exact decimal strings (the core bigint strategy);
         // the suffix and radix stay in the metadata for the write-back.
         const safe = big >= BigInt(Number.MIN_SAFE_INTEGER) && big <= BigInt(Number.MAX_SAFE_INTEGER);
@@ -228,8 +240,11 @@ class Parser {
             }
             if (c === '\\') {
                 const esc = this.src[this.pos + 1];
-                if (esc === 'x') {
-                    out += String.fromCharCode(parseInt(this.src.slice(this.pos + 2, this.pos + 4), 16));
+                if (esc === 'x' || esc === 'X') {
+                    const hex = this.src.slice(this.pos + 2, this.pos + 4);
+                    if (!/^[0-9A-Fa-f]{2}$/.test(hex))
+                        this.fail('\\x escape needs two hex digits');
+                    out += String.fromCharCode(parseInt(hex, 16));
                     this.pos += 4;
                     continue;
                 }
@@ -253,7 +268,7 @@ class Parser {
         }
         this.pos = lineEnd === -1 ? this.src.length : lineEnd + 1;
     }
-    /** Skip whitespace and all three comment forms. */
+    /** Skip whitespace, all three comment forms, and `@include` lines. */
     skipTrivia() {
         for (;;) {
             const c = this.src[this.pos];
@@ -261,6 +276,12 @@ class Parser {
                 this.pos++;
                 continue;
             }
+            // The C scanner handles `@include` at token level, so it is legal in any
+            // trivia position (even between list elements), not just between settings.
+            if (c === '@' && this.src.startsWith('@include', this.pos)) {
+                this.handleInclude();
+                continue;
+            }
             if (c === '#' || (c === '/' && this.src[this.pos + 1] === '/')) {
                 const nl = this.src.indexOf('\n', this.pos);
                 this.pos = nl === -1 ? this.src.length : nl;

package/dist/transformers/libconfig/revert.js

@@ -21,7 +21,8 @@ function patchGroup(src, group, value, edits) {
         patchValue(src, setting.value, value[setting.name], edits);
     }
     const known = new Set(group.settings.map((s) => s.name));
-    const added = Object.keys(value ?? {}).filter((k) => !known.has(k));
+    // null/undefined means "absent", never a value: such keys are not added.
+    const added = Object.keys(value ?? {}).filter((k) => !known.has(k) && value[k] != null);
     if (added.length) {
         edits.push(insertionEdit(src, group, added.map((k) => `${k} = ${serialize(value[k], '')};`)));
     }
@@ -31,6 +32,10 @@ function patchValue(src, node, value, edits) {
         case 'scalar': {
             if (node.value === value)
                 return;
+            // The collection-wide bigint carry hands safe elements back as digit
+            // strings; a string spelling the same value is not an edit.
+            if (typeof value === 'string' && typeof node.value === 'number' && value === String(node.value))
+                return;
             edits.push({ ...node.span, text: emitScalar(value, node) });
             return;
         }
@@ -43,9 +48,13 @@ function patchValue(src, node, value, edits) {
         case 'array': {
             if (Array.isArray(value))
                 return patchElements(src, node.elements, node, value, edits);
-            // The read-only raw carry of an untyped empty array: leave verbatim.
-            if (typeof value === 'string' && value === (0, schema_1.raw)(node, src))
-                return;
+            // A string here is the read-only raw carry of an untyped empty array:
+            // unchanged it stays verbatim, edited it is an error, never a splice.
+            if (typeof value === 'string') {
+                if (value === (0, schema_1.raw)(node, src))
+                    return;
+                throw new Error('this collection is read-only (no element type to edit by): the edited text was not applied');
+            }
             edits.push({ ...node.span, text: serialize(value, '') });
             return;
         }
@@ -64,11 +73,15 @@ function patchValue(src, node, value, edits) {
                 }
                 return;
             }
-            // Heterogeneous (read-only raw carry) or unchanged empty: only replace on
-            // a genuine mismatch with a non-raw value shape — otherwise leave verbatim.
-            if (typeof value === 'string' && value === (0, schema_1.raw)(node, src))
-                return;
-            if (value !== undefined && typeof value !== 'string') {
+            // Heterogeneous (read-only raw carry) or unchanged empty: the carry
+            // stays verbatim, an edited carry is an error, a non-string value is a
+            // genuine shape change and regenerates.
+            if (typeof value === 'string') {
+                if (value === (0, schema_1.raw)(node, src))
+                    return;
+                throw new Error('this list is read-only (heterogeneous): the edited text was not applied');
+            }
+            if (value !== undefined) {
                 edits.push({ ...node.span, text: serialize(value, '') });
             }
             return;
@@ -146,11 +159,17 @@ function emitScalar(value, node) {
     if (typeof value === 'boolean')
         return value ? 'true' : 'false';
     if (typeof value === 'string') {
-        // The int64 string carry: exact digits back, with the original suffix.
-        if (node.type === 'int64' && typeof node.value === 'string') {
+        if (node.type === 'int' || node.type === 'int64') {
             if (!/^[-+]?[0-9]+$/.test(value)) {
-                throw new Error(`'${value}' is not an integer: this setting carries a 64-bit integer as a string`);
+                throw new Error(`'${value}' is not an integer: this setting is integer-typed`);
             }
+            // The int64 string carry: exact digits back, with the original suffix.
+            if (typeof node.value === 'string')
+                return value + (node.int?.suffix ?? '');
+            // A safe element of a carried collection: back to its own literal style.
+            const n = Number(value);
+            if (Number.isSafeInteger(n))
+                return intLiteral(n, node.int);
             return value + (node.int?.suffix ?? '');
         }
         return quote(value);
@@ -165,13 +184,17 @@ function emitScalar(value, node) {
     }
     return serialize(value, '');
 }
-/** Integer in the source's radix and width, suffix preserved. */
+/**
+ * Integer in the source's radix, width, and prefix spelling, suffix preserved.
+ * Negatives always emit decimal: the C scanner accepts no sign on a
+ * hex/binary/octal literal, so `-0x1A` would not load.
+ */
 function intLiteral(value, meta) {
-    if (!meta || meta.radix === 10)
+    if (!meta || meta.radix === 10 || value < 0)
         return String(value) + (meta?.suffix ?? '');
-    const prefix = meta.radix === 16 ? '0x' : meta.radix === 2 ? '0b' : '0o';
-    const digits = Math.abs(value).toString(meta.radix).toUpperCase().padStart(meta.digits, '0');
-    return (value < 0 ? '-' : '') + prefix + digits + meta.suffix;
+    const prefix = meta.prefix || (meta.radix === 16 ? '0x' : meta.radix === 2 ? '0b' : '0o');
+    const digits = value.toString(meta.radix).toUpperCase().padStart(meta.digits, '0');
+    return prefix + digits + meta.suffix;
 }
 /** A float literal that stays a float: integral values gain `.0`. */
 function floatLiteral(value) {
@@ -206,9 +229,13 @@ function quote(value) {
  * grown collection). Typing is value-driven here: integral numbers emit as
  * ints, fractional as floats — a host that needs a float-typed `21.0` for a
  * fresh setting should send `21.0`-producing edits through an existing float
- * slot or accept the int typing (documented beta limitation).
+ * slot or accept the int typing. null/undefined have no libconfig literal
+ * and throw.
  */
 function serialize(value, indent) {
+    if (value == null) {
+        throw new Error('null/undefined has no libconfig representation: omit the setting instead');
+    }
     if (typeof value === 'boolean')
         return value ? 'true' : 'false';
     if (typeof value === 'number')
@@ -226,7 +253,7 @@ function serialize(value, indent) {
             .join(' ');
         return `{ ${body} }`;
     }
-    return 'true'; // null/undefined have no libconfig literal; unreachable via typed forms
+    throw new Error(`a ${typeof value} value has no libconfig representation`);
 }
 /** An integer string that exceeds the double-safe range (the bigint carry). */
 function isBigIntString(value) {

package/dist/transformers/libconfig/schema.js

@@ -80,14 +80,21 @@ function scalarLeaf(name, scalar) {
         case 'float':
             return { kind: 'leaf', name, type: 'number' };
         case 'int':
-            return { kind: 'leaf', name, type: 'number', integer: true };
+            return withRadix({ kind: 'leaf', name, type: 'number', integer: true }, scalar);
         case 'int64':
             // Beyond 2^53 the value rides as an exact decimal string.
             return typeof scalar.value === 'string'
-                ? { kind: 'leaf', name, type: 'string', pattern: INTEGER_STRING_PATTERN }
-                : { kind: 'leaf', name, type: 'number', integer: true };
+                ? withRadix({ kind: 'leaf', name, type: 'string', pattern: INTEGER_STRING_PATTERN }, scalar)
+                : withRadix({ kind: 'leaf', name, type: 'number', integer: true }, scalar);
     }
 }
+/** Carry a non-decimal literal's base onto the leaf as its display radix. */
+function withRadix(leaf, scalar) {
+    const radix = scalar.int?.radix;
+    if (radix && radix !== 10)
+        leaf.radix = radix;
+    return leaf;
+}
 /**
  * A homogeneous scalar collection → leafList. One int64 element beyond 2^53
  * degrades the whole list to string carry: a leafList holds one scalar type,
@@ -97,10 +104,23 @@ function listLeaf(name, elements) {
     if (elements.length === 0)
         return rawLeaf(name, 'empty collection');
     const f = (0, parser_1.family)(elements[0].type);
+    const radix = f === 'integer' ? sharedRadix(elements) : undefined;
     if (f === 'integer' && elements.some((e) => typeof e.value === 'string')) {
-        return { kind: 'leafList', name, type: 'string' };
+        return { kind: 'leafList', name, type: 'string', ...(radix && { radix }) };
     }
-    return { kind: 'leafList', name, type: f === 'integer' || f === 'float' ? 'number' : f === 'bool' ? 'boolean' : 'string' };
+    return {
+        kind: 'leafList',
+        name,
+        type: f === 'integer' || f === 'float' ? 'number' : f === 'bool' ? 'boolean' : 'string',
+        ...(radix && { radix }),
+    };
+}
+/** The display radix shared by every element, when uniform and non-decimal. */
+function sharedRadix(elements) {
+    const first = elements[0]?.int?.radix ?? 10;
+    if (first === 10)
+        return undefined;
+    return elements.every((e) => (e.int?.radix ?? 10) === first) ? first : undefined;
 }
 function arrayValue(elements) {
     const stringCarry = elements.length > 0 &&
@@ -149,12 +169,15 @@ function listShape(list) {
 }
 /** Read-only leaf carrying the collection's verbatim source text. */
 function rawLeaf(name, why) {
+    const hint = why === 'empty collection'
+        ? 'Provide a JSON Schema to type its elements and make it editable.'
+        : 'It stays read-only: no single element type exists to edit by.';
     return {
         kind: 'leaf',
         name,
         type: 'string',
         readOnly: true,
-        description: `Shown verbatim (${why}): libconfig gives no element type to edit by. Provide a JSON Schema to make it editable.`,
+        description: `Shown verbatim (${why}). ${hint}`,
     };
 }
 /** The verbatim source slice of a node. */

package/dist/transformers/yaml/yaml-transformer.js

@@ -30,6 +30,8 @@ exports.yamlTransformer = {
         const schema = options?.schema
             ? (0, json_schema_1.jsonSchemaToNodeGroup)(options.schema, options.rootName, options.schemaOptions)
             : (0, infer_1.inferNodeGroup)(data, options?.rootName);
+        if (!options?.schema && doc.contents)
+            annotateRadix(doc.contents, schema);
         const labeled = options?.thesaurus ? (0, thesaurus_1.applyThesaurus)(schema, options.thesaurus) : schema;
         return { schema: labeled, binding: doc, initialValue: data };
     },
@@ -41,6 +43,67 @@ exports.yamlTransformer = {
     // `satisfies` verifies conformance to the catalog contract while keeping the
     // concrete sync return types, so direct callers need no `await`.
 };
+const RADIX_BY_FORMAT = { BIN: 2, OCT: 8, HEX: 16 };
+/**
+ * Copy non-decimal integer presentation (`0x`/`0o`/`0b` literals) from the
+ * parsed document onto the inferred schema as leaf/leafList `radix` display
+ * hints — the plain-data inference cannot see them, because `toJS()` drops the
+ * scalar format. The revert needs nothing: scalars are mutated in place, so an
+ * edited value re-emits in its literal's own base. Across group-list items the
+ * first non-decimal occurrence wins — one shared item schema cannot vary the
+ * display per item. Schema-driven mode is untouched (JSON Schema has no radix
+ * vocabulary).
+ */
+function annotateRadix(node, schema) {
+    switch (schema.kind) {
+        case 'leaf': {
+            const radix = scalarRadix(node);
+            if (radix && !schema.radix)
+                schema.radix = radix;
+            return;
+        }
+        case 'leafList': {
+            if (!(0, yaml_1.isSeq)(node) || schema.radix)
+                return;
+            const radixes = node.items.map(scalarRadix);
+            if (radixes[0] && radixes.every((r) => r === radixes[0]))
+                schema.radix = radixes[0];
+            return;
+        }
+        case 'nodeGroup': {
+            if (!(0, yaml_1.isMap)(node))
+                return;
+            for (const pair of node.items) {
+                const child = schema.children[pairKey(pair.key)];
+                if (child)
+                    annotateRadix(pair.value, child);
+            }
+            return;
+        }
+        case 'nodeGroupList': {
+            if (!(0, yaml_1.isSeq)(node))
+                return;
+            for (const item of node.items)
+                annotateRadix(item, schema.type);
+            return;
+        }
+        default:
+            return; // choice/map never come out of plain-data inference
+    }
+}
+/** The display radix of a non-decimal integer scalar node, else undefined. */
+function scalarRadix(node) {
+    if (!(0, yaml_1.isScalar)(node))
+        return undefined;
+    if (typeof node.value !== 'number' && typeof node.value !== 'bigint')
+        return undefined;
+    return RADIX_BY_FORMAT[node.format ?? ''];
+}
+/** The string a key node takes as a JS object key, matching `doc.toJS()`. */
+function pairKey(key) {
+    const v = (0, yaml_1.isScalar)(key) ? key.value : key;
+    return v == null ? '' : String(v);
+}
 /**
  * Replace every BigInt from an `intAsBigInt` parse with a form-value scalar: a
  * plain `number` when it fits the safe range, otherwise its decimal string (so

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-form-foundry-transformers",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Framework-agnostic Node + TypeScript catalog of source-format transformers: turn a YANG model (and more) into an ng-form-foundry schema and revert the edited form value back to the source format.",
   "keywords": [
     "ng-form-foundry",