ng-form-foundry-transformers 0.5.1 → 0.5.3

package/README.md

@@ -155,6 +155,14 @@ enabled, so the output validates against the source schema (opt out with
 `schemaOptions: { optionalPresence: false }`); a required property mapping to a
 choice is marked `mandatory`.
 
+**The schema must agree with the document on container shapes.** A covered
+key whose schema says array where the document holds an object (or scalar
+where it holds a collection) makes `toSchema` throw a `SchemaShapeError`
+naming the path — such a form could not carry the section and saving would
+erase it. Catch it to fall back to inferred editing. Scalar-vs-scalar
+differences (a quoted `"0xe00"` under an `integer` schema) stay editable,
+and an integral edit writes back an integer literal.
+
 **The schema may cover any slice of the document.** Keys it does not mention
 are governed by `unknownKeys` (YAML, JSON, and libconfig alike):
 `'preserve'` (default) keeps them verbatim on save — a partial schema edits
@@ -301,6 +309,19 @@ npm test        # node:test on the compiled output (no Python needed)
 
 ## Status
 
+`0.5.3` — version-alignment release with the workspace (the paired
+`ng-form-foundry` 0.5.3 ships hover-revealed field actions and indexed
+group-list add labels); no transformer changes.
+
+`0.5.2` — **shape safety and operator-friendly display**: a container-shape
+disagreement between document and schema (array declared where the document
+holds an object, or scalar where it holds a collection — inside choices
+included) throws a `SchemaShapeError` naming the path instead of producing
+an empty form whose save would erase the section; a type-changing integral
+edit writes an integer literal, never a float; and schema-driven fields
+display hex/octal/binary values in the base the document wrote them, in
+every `unknownKeys` mode. Adversarially proof-tested before release.
+
 `0.5.1` — **partial JSON Schemas edit safely**: the new `unknownKeys` option
 (YAML, JSON, libconfig) governs keys the schema does not cover — `'preserve'`
 (default) keeps them verbatim on save, `'drop'` deletes them for

package/dist/core/index.d.ts

@@ -14,3 +14,4 @@ export type { NodeGroup, NodeType, Leaf, LeafList, NodeGroupList, Choice, Choice
 export { CASE_KEY } from './schema';
 export type { Thesaurus, ThesaurusEntry } from './schema';
 export { applyThesaurus } from './thesaurus';
+export { SchemaShapeError } from './shape-check';

package/dist/core/index.js

@@ -7,7 +7,7 @@
  * map a JSON Schema) that any data-oriented transformer reuses.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyThesaurus = exports.CASE_KEY = exports.jsonSchemaToNodeGroup = exports.inferNodeGroup = exports.TransformerRegistry = void 0;
+exports.SchemaShapeError = exports.applyThesaurus = exports.CASE_KEY = exports.jsonSchemaToNodeGroup = exports.inferNodeGroup = exports.TransformerRegistry = void 0;
 var registry_1 = require("./registry");
 Object.defineProperty(exports, "TransformerRegistry", { enumerable: true, get: function () { return registry_1.TransformerRegistry; } });
 // Shared schema builders — used by the YAML and JSON transformers alike.
@@ -19,3 +19,5 @@ var schema_1 = require("./schema");
 Object.defineProperty(exports, "CASE_KEY", { enumerable: true, get: function () { return schema_1.CASE_KEY; } });
 var thesaurus_1 = require("./thesaurus");
 Object.defineProperty(exports, "applyThesaurus", { enumerable: true, get: function () { return thesaurus_1.applyThesaurus; } });
+var shape_check_1 = require("./shape-check");
+Object.defineProperty(exports, "SchemaShapeError", { enumerable: true, get: function () { return shape_check_1.SchemaShapeError; } });

package/dist/core/schema-keys.d.ts

@@ -10,7 +10,7 @@
  * each document level, mirroring the wire encoding of
  * ng-form-foundry's `serializeForm`/`toWireValue`.
  */
-import type { NodeGroup, NodeType } from './schema';
+import type { Choice, NodeGroup, NodeType } from './schema';
 /**
  * The schema-born key set of one document level, as `name → child schema`
  * for recursion. `undefined` means "no schema in play": every key is
@@ -31,3 +31,10 @@ export type SchemaKeys = Map<string, NodeType | undefined> | undefined;
 export declare function childrenOf(node: NodeType): SchemaKeys;
 /** The per-item schema when `node` describes a list of groups, else undefined. */
 export declare function itemSchemaOf(node: NodeType | undefined): NodeGroup | undefined;
+/**
+ * A case body is a single node exactly when its `kind` is a *string* — a
+ * record body whose fields include one literally named `kind` (k8s-style
+ * schemas) holds a NodeType there, not a string. The `in` operator cannot
+ * tell the two apart.
+ */
+export declare function isSingleNodeBody(body: Choice['cases'][string]): body is NodeType;

package/dist/core/schema-keys.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.childrenOf = childrenOf;
 exports.itemSchemaOf = itemSchemaOf;
+exports.isSingleNodeBody = isSingleNodeBody;
 /**
  * The keys `serializeForm` can emit for a schema node standing at a document
  * object/group, with each key's schema for recursion. A nodeGroup
@@ -32,10 +33,19 @@ function childrenOf(node) {
 function itemSchemaOf(node) {
     return node?.kind === 'nodeGroupList' ? node.type : undefined;
 }
+/**
+ * A case body is a single node exactly when its `kind` is a *string* — a
+ * record body whose fields include one literally named `kind` (k8s-style
+ * schemas) holds a NodeType there, not a string. The `in` operator cannot
+ * tell the two apart.
+ */
+function isSingleNodeBody(body) {
+    return typeof body.kind === 'string';
+}
 /** Field name → schema across every case of a choice (leaf-bodied cases too). */
 function* caseEntries(choice) {
     for (const body of Object.values(choice.cases)) {
-        if ('kind' in body)
+        if (isSingleNodeBody(body))
             yield [body.name, body];
         else
             for (const [name, field] of Object.entries(body))

package/dist/core/shape-check.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Container-shape validation between a parsed document and a user-supplied
+ * JSON Schema's {@link NodeGroup}.
+ *
+ * A schema that declares a section a list while the document holds a group
+ * (or scalar, or vice versa) produces a form that cannot carry the section's
+ * contents — the form builder coerces the unusable initial value to an empty
+ * control, the form looks valid, and a save erases the section. For config
+ * files that program live systems, that silent path is the worst failure
+ * mode, so schema-driven `toSchema` refuses up front: the consumer catches
+ * {@link SchemaShapeError} and falls back to inferred editing or fixes the
+ * schema. Scalar-vs-scalar differences are *not* errors — a quoted `"0xe00"`
+ * under an `integer` schema is a legitimate wild-file shape the form can
+ * carry and edit.
+ */
+import type { NodeGroup } from './schema';
+/** A document/schema container-shape disagreement, pointing at the key path. */
+export declare class SchemaShapeError extends Error {
+    /** Path of the offending key, e.g. `gNBs` or `cells[0].id`. */
+    readonly path: string;
+    /** What the document holds there. */
+    readonly found: 'object' | 'array' | 'scalar';
+    /** What the schema declares there. */
+    readonly expected: 'object' | 'array' | 'scalar';
+    constructor(
+    /** Path of the offending key, e.g. `gNBs` or `cells[0].id`. */
+    path: string, 
+    /** What the document holds there. */
+    found: 'object' | 'array' | 'scalar', 
+    /** What the schema declares there. */
+    expected: 'object' | 'array' | 'scalar');
+}
+/**
+ * Walk the extracted document value against the JSON-Schema-derived schema
+ * and throw {@link SchemaShapeError} on the first container-kind
+ * disagreement. Only schema-covered keys are checked (absent keys are
+ * presence, uncovered keys are inference's business, and inference always
+ * matches the document by construction).
+ */
+export declare function assertSchemaShapes(data: unknown, schema: NodeGroup): void;

package/dist/core/shape-check.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaShapeError = void 0;
+exports.assertSchemaShapes = assertSchemaShapes;
+const schema_keys_1 = require("./schema-keys");
+/** A document/schema container-shape disagreement, pointing at the key path. */
+class SchemaShapeError extends Error {
+    constructor(
+    /** Path of the offending key, e.g. `gNBs` or `cells[0].id`. */
+    path, 
+    /** What the document holds there. */
+    found, 
+    /** What the schema declares there. */
+    expected) {
+        super(`'${path}': the document holds ${article(found)} here, but the schema expects ` +
+            `${article(expected)} — the form cannot carry its contents, and saving would erase them. ` +
+            `Align the schema with the document, or leave this key out of the schema.`);
+        this.path = path;
+        this.found = found;
+        this.expected = expected;
+        this.name = 'SchemaShapeError';
+    }
+}
+exports.SchemaShapeError = SchemaShapeError;
+function article(shape) {
+    return shape === 'array' ? 'an array' : shape === 'object' ? 'an object' : 'a scalar';
+}
+/**
+ * Walk the extracted document value against the JSON-Schema-derived schema
+ * and throw {@link SchemaShapeError} on the first container-kind
+ * disagreement. Only schema-covered keys are checked (absent keys are
+ * presence, uncovered keys are inference's business, and inference always
+ * matches the document by construction).
+ */
+function assertSchemaShapes(data, schema) {
+    checkNode(data, schema, '');
+}
+function checkNode(value, node, path) {
+    // Absent is presence semantics; null is either a nullable leaf's value or
+    // the empty-container idiom (YAML `section:`) — nothing exists to erase.
+    if (value == null)
+        return;
+    switch (node.kind) {
+        case 'leaf':
+            // Any primitive is carryable (string carries, quoted ints). An *empty*
+            // collection is too: the libconfig empty-collection carry under a
+            // string leaf round-trips as a no-op — only content can be erased.
+            if (isRecord(value))
+                throw new SchemaShapeError(path, 'object', 'scalar');
+            if (Array.isArray(value) && value.length > 0)
+                throw new SchemaShapeError(path, 'array', 'scalar');
+            return;
+        case 'leafList':
+            if (!Array.isArray(value))
+                throw new SchemaShapeError(path, shapeOf(value), 'array');
+            value.forEach((item, i) => {
+                if (isRecord(item) || Array.isArray(item)) {
+                    throw new SchemaShapeError(`${path}[${i}]`, shapeOf(item), 'scalar');
+                }
+            });
+            return;
+        case 'nodeGroupList':
+            if (!Array.isArray(value))
+                throw new SchemaShapeError(path, shapeOf(value), 'array');
+            value.forEach((item, i) => {
+                if (!isRecord(item))
+                    throw new SchemaShapeError(`${path}[${i}]`, shapeOf(item), 'object');
+                checkChildren(item, node.type, `${path}[${i}]`);
+            });
+            return;
+        case 'nodeGroup':
+        case 'map':
+            if (!isRecord(value))
+                throw new SchemaShapeError(path, shapeOf(value), 'object');
+            checkChildren(value, node, path);
+            return;
+        case 'choice': {
+            // The document's shape must be one some case can carry: a record for
+            // record-bodied cases, an array for a collection-bodied case, a scalar
+            // for a leaf-bodied case. An array under object-only cases (or a
+            // record under scalar-only cases) is exactly the uncarryable-section
+            // erasure this check exists to refuse.
+            const allowed = caseShapes(node);
+            const found = shapeOf(value);
+            if (!allowed.has(found)) {
+                throw new SchemaShapeError(path, found, preferredShape(allowed));
+            }
+            if (isRecord(value))
+                checkChildren(value, node, path);
+            return;
+        }
+    }
+}
+/** The container shapes a choice's cases can carry, unioned across cases. */
+function caseShapes(choice) {
+    const shapes = new Set();
+    for (const body of Object.values(choice.cases)) {
+        if (!(0, schema_keys_1.isSingleNodeBody)(body)) {
+            shapes.add('object'); // a record of named fields
+            continue;
+        }
+        switch (body.kind) {
+            case 'nodeGroup':
+            case 'map':
+                shapes.add('object');
+                break;
+            case 'nodeGroupList':
+            case 'leafList':
+                shapes.add('array');
+                break;
+            case 'leaf':
+                shapes.add('scalar');
+                break;
+            case 'choice': // a nested choice's own cases are unknowable here: permissive
+                shapes.add('object').add('array').add('scalar');
+                break;
+        }
+    }
+    return shapes;
+}
+/** A single representative shape for the error message, objects first. */
+function preferredShape(allowed) {
+    if (allowed.has('object'))
+        return 'object';
+    if (allowed.has('array'))
+        return 'array';
+    return 'scalar';
+}
+/** Recurse a record's own keys through the node's schema-born children. */
+function checkChildren(record, node, path) {
+    const keys = (0, schema_keys_1.childrenOf)(node);
+    if (!keys)
+        return;
+    for (const key of Object.keys(record)) {
+        const child = keys.get(key);
+        if (child)
+            checkNode(record[key], child, path ? `${path}.${key}` : key);
+    }
+}
+function shapeOf(value) {
+    if (Array.isArray(value))
+        return 'array';
+    return isRecord(value) ? 'object' : 'scalar';
+}
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}

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

@@ -6,3 +6,4 @@
  */
 export { jsonTransformer } from './json-transformer';
 export type { JsonOptions, JsonFormat } from './json-transformer';
+export { SchemaShapeError } from '../../core/shape-check';

package/dist/transformers/json/index.js

@@ -6,6 +6,10 @@
  * schema builders in `core`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonTransformer = void 0;
+exports.SchemaShapeError = exports.jsonTransformer = void 0;
 var json_transformer_1 = require("./json-transformer");
 Object.defineProperty(exports, "jsonTransformer", { enumerable: true, get: function () { return json_transformer_1.jsonTransformer; } });
+// Thrown by schema-driven toSchema; re-exported so subpath consumers can
+// catch it by instance.
+var shape_check_1 = require("../../core/shape-check");
+Object.defineProperty(exports, "SchemaShapeError", { enumerable: true, get: function () { return shape_check_1.SchemaShapeError; } });

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

@@ -7,6 +7,7 @@ const json_schema_1 = require("../../core/json-schema");
 const bigint_1 = require("../../core/bigint");
 const schema_keys_1 = require("../../core/schema-keys");
 const merge_inferred_1 = require("../../core/merge-inferred");
+const shape_check_1 = require("../../core/shape-check");
 /**
  * A JSON {@link Transformer}: turn a JSON config document into a form and write
  * the edited value back to JSON. The form is built by the same format-agnostic
@@ -40,6 +41,10 @@ exports.jsonTransformer = {
         const schema = fromJsonSchema && unknownKeys === 'edit'
             ? (0, merge_inferred_1.mergeInferred)(fromJsonSchema, (0, infer_1.inferNodeGroup)(data, options?.rootName))
             : fromJsonSchema ?? (0, infer_1.inferNodeGroup)(data, options?.rootName);
+        // A container-shape disagreement between document and schema would erase
+        // the section on save: refuse up front (see assertSchemaShapes).
+        if (fromJsonSchema)
+            (0, shape_check_1.assertSchemaShapes)(data, fromJsonSchema);
         const labeled = options?.thesaurus ? (0, thesaurus_1.applyThesaurus)(schema, options.thesaurus) : schema;
         // 'preserve' gates the revert on the JSON Schema's NodeGroup; 'edit' on
         // the merged one (schema-born ≈ everything, but keys no form field can

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

@@ -1,2 +1,3 @@
 export { libconfigTransformer, type LibconfigBinding, type LibconfigOptions, } from './libconfig-transformer';
 export { parseLibconfig, LibconfigParseError } from './parser';
+export { SchemaShapeError } from '../../core/shape-check';

package/dist/transformers/libconfig/index.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LibconfigParseError = exports.parseLibconfig = exports.libconfigTransformer = void 0;
+exports.SchemaShapeError = 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; } });
 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; } });
+// Thrown by schema-driven toSchema; re-exported so browser consumers of this
+// subpath can catch it by instance.
+var shape_check_1 = require("../../core/shape-check");
+Object.defineProperty(exports, "SchemaShapeError", { enumerable: true, get: function () { return shape_check_1.SchemaShapeError; } });

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

@@ -5,6 +5,7 @@ const thesaurus_1 = require("../../core/thesaurus");
 const json_schema_1 = require("../../core/json-schema");
 const merge_inferred_1 = require("../../core/merge-inferred");
 const schema_keys_1 = require("../../core/schema-keys");
+const shape_check_1 = require("../../core/shape-check");
 const parser_1 = require("./parser");
 const schema_1 = require("./schema");
 const revert_1 = require("./revert");
@@ -19,8 +20,17 @@ exports.libconfigTransformer = {
         const schema = fromJsonSchema && unknownKeys === 'edit'
             ? (0, merge_inferred_1.mergeInferred)(fromJsonSchema, (0, schema_1.libconfigToNodeGroup)(root, source, options?.rootName ?? '__root__'))
             : fromJsonSchema ?? (0, schema_1.libconfigToNodeGroup)(root, source, options?.rootName ?? '__root__');
+        // Schema-driven leaves display in the base the document wrote them in —
+        // the JSON Schema cannot know it, the document does (see annotateSchemaRadix).
+        if (fromJsonSchema)
+            (0, schema_1.annotateSchemaRadix)(root, schema);
         const labeled = options?.thesaurus ? (0, thesaurus_1.applyThesaurus)(schema, options.thesaurus) : schema;
         const initialValue = (0, schema_1.extractValue)(root, source, options?.schema != null);
+        // A container-shape disagreement (group vs list vs scalar) produces a
+        // form that cannot carry the section and would erase it on save: refuse
+        // up front so the consumer can fall back to inferred editing.
+        if (fromJsonSchema)
+            (0, shape_check_1.assertSchemaShapes)(initialValue, fromJsonSchema);
         if (fromJsonSchema && unknownKeys === 'edit') {
             // Uncovered empty collections merged as read-only carries: their value
             // must be the verbatim slice, not the typed [] the extraction produced.

package/dist/transformers/libconfig/revert.js

@@ -197,7 +197,10 @@ function emitScalar(value, node) {
         if ((node.type === 'int' || node.type === 'int64') && Number.isInteger(value)) {
             return intLiteral(value, node.int);
         }
-        return floatLiteral(value); // a fractional edit into an int slot: emit honestly
+        // A type-changing edit (e.g. a quoted "0xe00" slot edited to a number
+        // under an integer schema): integral values emit an int literal —
+        // float form is reserved for genuinely fractional values.
+        return Number.isInteger(value) ? String(value) : floatLiteral(value);
     }
     return serialize(value, '');
 }

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

@@ -18,7 +18,7 @@
  *   transformer options) replaces this inference entirely and makes typed
  *   empty collections editable.
  */
-import type { NodeGroup } from '../../core/schema';
+import type { NodeGroup, NodeType } from '../../core/schema';
 import { type SchemaKeys } from '../../core/schema-keys';
 import { type CfgGroup, type CfgList, type CfgValue } from './parser';
 /** Infer the root NodeGroup for a parsed document. */
@@ -37,6 +37,19 @@ type ListShape = 'groups' | 'scalars' | 'empty' | 'heterogeneous';
 export declare function listShape(list: CfgList): ListShape;
 /** The verbatim source slice of a node. */
 export declare function raw(value: CfgValue, source: string): string;
+/**
+ * Stamp the document's non-decimal integer presentation onto a
+ * **schema-driven** NodeGroup as `radix` display hints — the JSON Schema has
+ * no radix vocabulary, so the document is the only authority on how a value
+ * is written. Covered number/string leaves whose literal is hex/octal/binary
+ * (and homogeneous collections thereof) display in that base in every
+ * `unknownKeys` mode, matching what inference does for uncovered fields.
+ * Fills gaps only: a `radix` already on the leaf (e.g. carried by
+ * `mergeInferred` under `'edit'`) wins. Keyed containers — groups, choices,
+ * maps — resolve through {@link childrenOf}, so case fields and map entries
+ * annotate too.
+ */
+export declare function annotateSchemaRadix(node: CfgValue, schema: NodeType): void;
 /**
  * `unknownKeys: 'edit'` extraction fixup. The whole-document extraction runs
  * with `emptyAsArrays` (schema-covered empty collections are typed and

package/dist/transformers/libconfig/schema.js

@@ -4,6 +4,7 @@ exports.libconfigToNodeGroup = libconfigToNodeGroup;
 exports.extractValue = extractValue;
 exports.listShape = listShape;
 exports.raw = raw;
+exports.annotateSchemaRadix = annotateSchemaRadix;
 exports.carryUncoveredEmpties = carryUncoveredEmpties;
 const schema_keys_1 = require("../../core/schema-keys");
 const parser_1 = require("./parser");
@@ -186,6 +187,63 @@ function rawLeaf(name, why) {
 function raw(value, source) {
     return source.slice(value.span.start, value.span.end);
 }
+/**
+ * Stamp the document's non-decimal integer presentation onto a
+ * **schema-driven** NodeGroup as `radix` display hints — the JSON Schema has
+ * no radix vocabulary, so the document is the only authority on how a value
+ * is written. Covered number/string leaves whose literal is hex/octal/binary
+ * (and homogeneous collections thereof) display in that base in every
+ * `unknownKeys` mode, matching what inference does for uncovered fields.
+ * Fills gaps only: a `radix` already on the leaf (e.g. carried by
+ * `mergeInferred` under `'edit'`) wins. Keyed containers — groups, choices,
+ * maps — resolve through {@link childrenOf}, so case fields and map entries
+ * annotate too.
+ */
+function annotateSchemaRadix(node, schema) {
+    switch (schema.kind) {
+        case 'leaf': {
+            // Only number/string leaves render radix; a boolean/enum leaf covering
+            // an int literal is a scalar-type mismatch the form handles otherwise.
+            if (schema.type !== 'number' && schema.type !== 'string')
+                return;
+            if (node.kind === 'scalar' && node.int && node.int.radix !== 10 && !schema.radix) {
+                schema.radix = node.int.radix;
+            }
+            return;
+        }
+        case 'leafList': {
+            if (schema.radix)
+                return;
+            if ((node.kind === 'array' || node.kind === 'list') && node.elements.every((e) => e.kind === 'scalar')) {
+                const radix = sharedRadix(node.elements);
+                if (radix)
+                    schema.radix = radix;
+            }
+            return;
+        }
+        case 'nodeGroupList': {
+            if (node.kind !== 'list')
+                return;
+            for (const el of node.elements)
+                annotateSchemaRadix(el, schema.type);
+            return;
+        }
+        default: {
+            // nodeGroup / choice / map — keyed containers over a document group.
+            if (node.kind !== 'group')
+                return;
+            const keys = (0, schema_keys_1.childrenOf)(schema);
+            if (!keys)
+                return;
+            for (const setting of node.settings) {
+                const child = keys.get(setting.name);
+                if (child)
+                    annotateSchemaRadix(setting.value, child);
+            }
+            return;
+        }
+    }
+}
 /**
  * `unknownKeys: 'edit'` extraction fixup. The whole-document extraction runs
  * with `emptyAsArrays` (schema-covered empty collections are typed and

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

@@ -9,3 +9,4 @@
 export { yamlTransformer } from './yaml-transformer';
 export type { YamlOptions, YamlBinding } from './yaml-transformer';
 export { applyValueToDocument } from './revert';
+export { SchemaShapeError } from '../../core/shape-check';

package/dist/transformers/yaml/index.js

@@ -8,8 +8,12 @@
  * `core` — they are format-agnostic and shared with the JSON transformer.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyValueToDocument = exports.yamlTransformer = void 0;
+exports.SchemaShapeError = exports.applyValueToDocument = exports.yamlTransformer = void 0;
 var yaml_transformer_1 = require("./yaml-transformer");
 Object.defineProperty(exports, "yamlTransformer", { enumerable: true, get: function () { return yaml_transformer_1.yamlTransformer; } });
 var revert_1 = require("./revert");
 Object.defineProperty(exports, "applyValueToDocument", { enumerable: true, get: function () { return revert_1.applyValueToDocument; } });
+// Thrown by schema-driven toSchema; re-exported so subpath consumers can
+// catch it by instance.
+var shape_check_1 = require("../../core/shape-check");
+Object.defineProperty(exports, "SchemaShapeError", { enumerable: true, get: function () { return shape_check_1.SchemaShapeError; } });

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

@@ -6,6 +6,8 @@ const thesaurus_1 = require("../../core/thesaurus");
 const infer_1 = require("../../core/infer");
 const json_schema_1 = require("../../core/json-schema");
 const merge_inferred_1 = require("../../core/merge-inferred");
+const schema_keys_1 = require("../../core/schema-keys");
+const shape_check_1 = require("../../core/shape-check");
 const bigint_1 = require("../../core/bigint");
 const revert_1 = require("./revert");
 /**
@@ -36,9 +38,14 @@ exports.yamlTransformer = {
         const schema = fromJsonSchema && unknownKeys === 'edit'
             ? (0, merge_inferred_1.mergeInferred)(fromJsonSchema, (0, infer_1.inferNodeGroup)(data, options?.rootName))
             : fromJsonSchema ?? (0, infer_1.inferNodeGroup)(data, options?.rootName);
-        // Inferred leaves (the whole schema, or the uncovered slice under 'edit')
-        // pick up the document's hex/octal presentation.
-        if ((!fromJsonSchema || unknownKeys === 'edit') && doc.contents)
+        // A container-shape disagreement between document and schema would erase
+        // the section on save: refuse up front (see assertSchemaShapes).
+        if (fromJsonSchema)
+            (0, shape_check_1.assertSchemaShapes)(data, fromJsonSchema);
+        // Every mode picks up the document's hex/octal presentation: inference
+        // for its own leaves, schema-driven leaves too — the JSON Schema cannot
+        // know the base a value was written in, the document does.
+        if (doc.contents)
             annotateRadix(doc.contents, schema);
         const labeled = options?.thesaurus ? (0, thesaurus_1.applyThesaurus)(schema, options.thesaurus) : schema;
         return {
@@ -62,17 +69,23 @@ exports.yamlTransformer = {
 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).
+ * parsed document onto the schema as leaf/leafList `radix` display hints —
+ * neither plain-data inference (`toJS()` drops the scalar format) nor a JSON
+ * Schema (no radix vocabulary) can know the base a value was written in; the
+ * document is the only authority. Runs in every mode and fills gaps only, so
+ * a `radix` already on a leaf wins. 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. Keyed containers — groups,
+ * choices, maps — resolve their children through {@link childrenOf}, so case
+ * fields and map entries annotate too.
  */
 function annotateRadix(node, schema) {
     switch (schema.kind) {
         case 'leaf': {
+            // Only number/string leaves render radix.
+            if (schema.type !== 'number' && schema.type !== 'string')
+                return;
             const radix = scalarRadix(node);
             if (radix && !schema.radix)
                 schema.radix = radix;
@@ -86,25 +99,27 @@ function annotateRadix(node, schema) {
                 schema.radix = radixes[0];
             return;
         }
-        case 'nodeGroup': {
+        case 'nodeGroupList': {
+            if (!(0, yaml_1.isSeq)(node))
+                return;
+            for (const item of node.items)
+                annotateRadix(item, schema.type);
+            return;
+        }
+        default: {
+            // nodeGroup / choice / map — keyed containers over a document mapping.
             if (!(0, yaml_1.isMap)(node))
                 return;
+            const keys = (0, schema_keys_1.childrenOf)(schema);
+            if (!keys)
+                return;
             for (const pair of node.items) {
-                const child = schema.children[pairKey(pair.key)];
+                const child = keys.get(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. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-form-foundry-transformers",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "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",