cddl2ts 0.7.1 → 0.8.0

package/README.md

@@ -23,6 +23,12 @@ This package exposes a CLI as well as a programmatic interface for transforming
 npx cddl2ts ./path/to/interface.cddl &> ./path/to/interface.ts
 ```
 
+Generated interface fields default to `camelCase`. Pass `--field-case snake` to emit `snake_case` fields while keeping exported interface and type names unchanged.
+
+```sh
+npx cddl2ts ./path/to/interface.cddl --field-case snake &> ./path/to/interface.ts
+```
+
 ### Programmatic Interface
 
 The module exports a `transform` method that takes a CDDL AST object and returns a TypeScript definition as `string`, e.g.:
@@ -41,16 +47,16 @@ import { parse, transform } from 'cddl'
  * };
  */
 const ast = parse('./spec.cddl')
-const ts = transform(ast)
+const ts = transform(ast, { fieldCase: 'snake' })
 console.log(ts)
 /**
  * outputs:
  *
  * interface SessionCapabilityRequest {
- *   acceptInsecureCerts?: boolean,
- *   browserName?: string,
- *   browserVersion?: string,
- *   platformName?: string,
+ *   accept_insecure_certs?: boolean,
+ *   browser_name?: string,
+ *   browser_version?: string,
+ *   platform_name?: string,
  * }
  */
 ```

package/build/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AASA,wBAA8B,GAAG,CAAE,IAAI,WAAwB,sBAgC9D"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAWA,wBAA8B,GAAG,CAAE,IAAI,WAAwB,sBAyC9D"}

package/build/cli.js

@@ -4,6 +4,7 @@ import yargs from 'yargs';
 import { parse } from 'cddl';
 import { transform } from './index.js';
 import { pkg } from './constants.js';
+const FIELD_CASE_CHOICES = ['camel', 'snake'];
 export default async function cli(argv = process.argv.slice(2)) {
     const parser = yargs(argv)
         .usage(`${pkg.name}\n${pkg.description}\n\nUsage:\nrunme2ts ./path/to/spec.cddl &> ./path/to/interface.ts`)
@@ -14,6 +15,12 @@ export default async function cli(argv = process.argv.slice(2)) {
         type: 'boolean',
         description: 'Use unknown instead of any',
         default: false
+    })
+        .option('field-case', {
+        choices: FIELD_CASE_CHOICES,
+        type: 'string',
+        description: 'Case for generated interface fields',
+        default: 'camel'
     })
         .help('help')
         .alias('h', 'help')
@@ -30,5 +37,8 @@ export default async function cli(argv = process.argv.slice(2)) {
         return process.exit(1);
     }
     const ast = parse(absoluteFilePath);
-    console.log(transform(ast, { useUnknown: args.u }));
+    console.log(transform(ast, {
+        useUnknown: args.u,
+        fieldCase: args.fieldCase
+    }));
 }

package/build/index.d.ts

@@ -1,6 +1,8 @@
 import { type Assignment } from 'cddl';
+export type FieldCase = 'camel' | 'snake';
 export interface TransformOptions {
     useUnknown?: boolean;
+    fieldCase?: FieldCase;
 }
 export declare function transform(assignments: Assignment[], options?: TransformOptions): string;
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAWH,KAAK,UAAU,EAMlB,MAAM,MAAM,CAAA;AAyCb,MAAM,WAAW,gBAAgB;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAA;CACvB;AAED,wBAAgB,SAAS,CAAE,WAAW,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,UAwB/E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAWH,KAAK,UAAU,EAMlB,MAAM,MAAM,CAAA;AAwCb,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,OAAO,CAAA;AAIzC,MAAM,WAAW,gBAAgB;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,SAAS,CAAA;CACxB;AAED,wBAAgB,SAAS,CAAE,WAAW,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,UA8B/E"}

package/build/index.js

@@ -36,8 +36,14 @@ const RECORD_KEY_TYPES = new Set([
     'float', 'float16', 'float32', 'float64', 'float16-32', 'float32-64',
     'str', 'text', 'tstr'
 ]);
+const IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 export function transform(assignments, options) {
-    if (options?.useUnknown) {
+    const transformOptions = {
+        useUnknown: false,
+        fieldCase: 'camel',
+        ...options
+    };
+    if (transformOptions.useUnknown) {
         NATIVE_TYPES.any = b.tsUnknownKeyword();
     }
     else {
@@ -49,7 +55,7 @@ export function transform(assignments, options) {
         sourceRoot: process.cwd()
     });
     for (const assignment of assignments) {
-        const statement = parseAssignment(assignment);
+        const statement = parseAssignment(assignment, transformOptions);
         if (!statement) {
             continue;
         }
@@ -57,7 +63,42 @@ export function transform(assignments, options) {
     }
     return print(ast).code;
 }
-function parseAssignment(assignment) {
+function getAssignmentComments(assignment) {
+    return assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
+}
+function exportWithComments(declaration) {
+    const expr = b.exportDeclaration(false, declaration);
+    expr.comments = declaration.comments;
+    declaration.comments = [];
+    return expr;
+}
+function isExtensibleRecordProperty(prop) {
+    return !isUnNamedProperty(prop) &&
+        prop.Occurrence.m === Infinity &&
+        !prop.HasCut &&
+        RECORD_KEY_TYPES.has(prop.Name);
+}
+function toSnakeCase(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+        .replace(/[^A-Za-z0-9_$]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toLowerCase();
+}
+function formatFieldName(name, fieldCase) {
+    return fieldCase === 'snake'
+        ? toSnakeCase(name)
+        : camelcase(name);
+}
+function createPropertyKey(name, options) {
+    const fieldName = formatFieldName(name, options.fieldCase);
+    return IDENTIFIER_PATTERN.test(fieldName)
+        ? b.identifier(fieldName)
+        : b.stringLiteral(fieldName);
+}
+function parseAssignment(assignment, options) {
     if (isVariable(assignment)) {
         const propType = Array.isArray(assignment.PropertyType)
             ? assignment.PropertyType
@@ -69,11 +110,11 @@ function parseAssignment(assignment) {
             typeParameters = b.tsNumberKeyword();
         }
         else {
-            typeParameters = b.tsUnionType(propType.map(parseUnionType));
+            typeParameters = b.tsUnionType(propType.map((prop) => parseUnionType(prop, options)));
         }
         const expr = b.tsTypeAliasDeclaration(id, typeParameters);
-        expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
-        return b.exportDeclaration(false, expr);
+        expr.comments = getAssignmentComments(assignment);
+        return exportWithComments(expr);
     }
     if (isGroup(assignment)) {
         const id = b.identifier(pascalCase(assignment.Name));
@@ -99,7 +140,7 @@ function parseAssignment(assignment) {
                         choiceOptions.push(nextProp);
                         i++; // Skip next property
                     }
-                    const options = choiceOptions.map(p => {
+                    const choiceTypes = choiceOptions.map(p => {
                         // If p is a group reference (Name ''), it's a TypeReference
                         // e.g. SessionAutodetectProxyConfiguration // SessionDirectProxyConfiguration
                         // The parser sometimes wraps it in an array, sometimes not (if inside a choice)
@@ -110,12 +151,12 @@ function parseAssignment(assignment) {
                             if (isNamedGroupReference(typeVal)) {
                                 return b.tsTypeReference(b.identifier(pascalCase(typeVal.Value || typeVal.Type)));
                             }
-                            return parseUnionType(typeVal);
+                            return parseUnionType(typeVal, options);
                         }
                         // Otherwise it is an object literal with this property
-                        return b.tsTypeLiteral(parseObjectType([p]));
+                        return b.tsTypeLiteral(parseObjectType([p], options));
                     });
-                    intersections.push(b.tsUnionType(options));
+                    intersections.push(b.tsUnionType(choiceTypes));
                 }
                 else {
                     staticProps.push(prop);
@@ -126,12 +167,12 @@ function parseAssignment(assignment) {
                 const mixins = staticProps.filter(isUnNamedProperty);
                 const ownProps = staticProps.filter(p => !isUnNamedProperty(p));
                 if (ownProps.length > 0) {
-                    intersections.unshift(b.tsTypeLiteral(parseObjectType(ownProps)));
+                    intersections.unshift(b.tsTypeLiteral(parseObjectType(ownProps, options)));
                 }
                 for (const mixin of mixins) {
                     if (Array.isArray(mixin.Type) && mixin.Type.length > 1) {
-                        const options = mixin.Type.map(parseUnionType);
-                        intersections.push(b.tsUnionType(options));
+                        const choices = mixin.Type.map((type) => parseUnionType(type, options));
+                        intersections.push(b.tsUnionType(choices));
                     }
                     else {
                         const typeVal = Array.isArray(mixin.Type) ? mixin.Type[0] : mixin.Type;
@@ -154,8 +195,8 @@ function parseAssignment(assignment) {
                 value = b.tsIntersectionType(intersections);
             }
             const expr = b.tsTypeAliasDeclaration(id, value);
-            expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
-            return b.exportDeclaration(false, expr);
+            expr.comments = getAssignmentComments(assignment);
+            return exportWithComments(expr);
         }
         const props = properties;
         /**
@@ -165,10 +206,10 @@ function parseAssignment(assignment) {
             const prop = props[0];
             const propType = Array.isArray(prop.Type) ? prop.Type : [prop.Type];
             if (propType.length === 1 && RECORD_KEY_TYPES.has(prop.Name)) {
-                const value = parseUnionType(assignment);
+                const value = parseUnionType(assignment, options);
                 const expr = b.tsTypeAliasDeclaration(id, value);
-                expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
-                return b.exportDeclaration(false, expr);
+                expr.comments = getAssignmentComments(assignment);
+                return exportWithComments(expr);
             }
         }
         // Check if extended interfaces are likely unions or conflicting types
@@ -210,10 +251,10 @@ function parseAssignment(assignment) {
                     const choices = [];
                     for (const prop of group.Properties) {
                         // Choices are wrapped in arrays in the properties
-                        const options = Array.isArray(prop) ? prop : [prop];
-                        if (options.length > 1) { // It's a choice within the mixin group
+                        const choiceProps = Array.isArray(prop) ? prop : [prop];
+                        if (choiceProps.length > 1) { // It's a choice within the mixin group
                             const unionOptions = [];
-                            for (const option of options) {
+                            for (const option of choiceProps) {
                                 let refName;
                                 const type = option.Type;
                                 if (typeof type === 'string')
@@ -245,7 +286,7 @@ function parseAssignment(assignment) {
                                 continue;
                             }
                         }
-                        for (const option of options) {
+                        for (const option of choiceProps) {
                             let refName;
                             const type = option.Type;
                             if (typeof type === 'string') {
@@ -340,7 +381,7 @@ function parseAssignment(assignment) {
                             }
                             else if (type && typeof type === 'object') {
                                 if (isGroup(type) && Array.isArray(type.Properties)) {
-                                    choices.push(b.tsTypeLiteral(parseObjectType(type.Properties)));
+                                    choices.push(b.tsTypeLiteral(parseObjectType(type.Properties, options)));
                                     continue;
                                 }
                                 refName = isNamedGroupReference(type)
@@ -375,7 +416,7 @@ function parseAssignment(assignment) {
             }
             const ownProps = props.filter(p => !isUnNamedProperty(p));
             if (ownProps.length > 0) {
-                intersections.push(b.tsTypeLiteral(parseObjectType(ownProps)));
+                intersections.push(b.tsTypeLiteral(parseObjectType(ownProps, options)));
             }
             let value;
             if (intersections.length === 1) {
@@ -385,14 +426,14 @@ function parseAssignment(assignment) {
                 value = b.tsIntersectionType(intersections);
             }
             const expr = b.tsTypeAliasDeclaration(id, value);
-            expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
-            return b.exportDeclaration(false, expr);
+            expr.comments = getAssignmentComments(assignment);
+            return exportWithComments(expr);
         }
         // Fallback to interface if no mixins (pure object)
-        const objectType = parseObjectType(props);
+        const objectType = parseObjectType(props, options);
         const expr = b.tsInterfaceDeclaration(id, b.tsInterfaceBody(objectType));
-        expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
-        return b.exportDeclaration(false, expr);
+        expr.comments = getAssignmentComments(assignment);
+        return exportWithComments(expr);
     }
     if (isCDDLArray(assignment)) {
         const id = b.identifier(pascalCase(assignment.Name));
@@ -404,30 +445,30 @@ function parseAssignment(assignment) {
             // We need to parse each choice.
             const obj = assignmentValues.map((prop) => {
                 const t = Array.isArray(prop.Type) ? prop.Type[0] : prop.Type;
-                return parseUnionType(t);
+                return parseUnionType(t, options);
             });
             const value = b.tsArrayType(b.tsParenthesizedType(b.tsUnionType(obj)));
             const expr = b.tsTypeAliasDeclaration(id, value);
-            expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
-            return b.exportDeclaration(false, expr);
+            expr.comments = getAssignmentComments(assignment);
+            return exportWithComments(expr);
         }
         // Standard array
         const firstType = assignmentValues.Type;
         const obj = Array.isArray(firstType)
-            ? firstType.map(parseUnionType)
+            ? firstType.map((type) => parseUnionType(type, options))
             : isCDDLArray(firstType)
-                ? firstType.Values.map((val) => parseUnionType(Array.isArray(val.Type) ? val.Type[0] : val.Type))
-                : [parseUnionType(firstType)];
+                ? firstType.Values.map((val) => parseUnionType(Array.isArray(val.Type) ? val.Type[0] : val.Type, options))
+                : [parseUnionType(firstType, options)];
         const value = b.tsArrayType(obj.length === 1
             ? obj[0]
             : b.tsParenthesizedType(b.tsUnionType(obj)));
         const expr = b.tsTypeAliasDeclaration(id, value);
-        expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true));
-        return b.exportDeclaration(false, expr);
+        expr.comments = getAssignmentComments(assignment);
+        return exportWithComments(expr);
     }
     throw new Error(`Unknown assignment type "${assignment.Type}"`);
 }
-function parseObjectType(props) {
+function parseObjectType(props, options) {
     const propItems = [];
     for (const prop of props) {
         /**
@@ -444,16 +485,29 @@ function parseObjectType(props) {
         if (isUnNamedProperty(prop)) {
             continue;
         }
-        const id = b.identifier(camelcase(prop.Name));
         const cddlType = Array.isArray(prop.Type) ? prop.Type : [prop.Type];
         const comments = prop.Comments.map((c) => ` ${c.Content}`);
+        if (isExtensibleRecordProperty(prop)) {
+            const keyIdentifier = b.identifier('key');
+            keyIdentifier.typeAnnotation = b.tsTypeAnnotation(NATIVE_TYPES[prop.Name]);
+            const indexSignature = b.tsIndexSignature([keyIdentifier], b.tsTypeAnnotation(b.tsUnionType([
+                ...cddlType.map((t) => parseUnionType(t, options)),
+                b.tsUndefinedKeyword()
+            ])));
+            indexSignature.comments = comments.length
+                ? [b.commentBlock(`*\n *${comments.join('\n *')}\n `)]
+                : [];
+            propItems.push(indexSignature);
+            continue;
+        }
+        const id = createPropertyKey(prop.Name, options);
         if (prop.Operator && prop.Operator.Type === 'default') {
             const defaultValue = parseDefaultValue(prop.Operator);
             defaultValue && comments.length && comments.push(''); // add empty line if we have previous comments
             defaultValue && comments.push(` @default ${defaultValue}`);
         }
         const type = cddlType.map((t) => {
-            const unionType = parseUnionType(t);
+            const unionType = parseUnionType(t, options);
             if (unionType) {
                 const defaultValue = parseDefaultValue(t.Operator);
                 defaultValue && comments.length && comments.push(''); // add empty line if we have previous comments
@@ -470,7 +524,7 @@ function parseObjectType(props) {
     }
     return propItems;
 }
-function parseUnionType(t) {
+function parseUnionType(t, options) {
     if (typeof t === 'string') {
         if (!NATIVE_TYPES[t]) {
             throw new Error(`Unknown native type: "${t}`);
@@ -496,31 +550,31 @@ function parseUnionType(t) {
              * Check if we have choices in the group (arrays of Properties)
              */
             if (prop.some(p => Array.isArray(p))) {
-                const options = [];
+                const choices = [];
                 for (const choice of prop) {
                     const subProps = Array.isArray(choice) ? choice : [choice];
                     if (subProps.length === 1 && isUnNamedProperty(subProps[0])) {
                         const first = subProps[0];
                         const subType = Array.isArray(first.Type) ? first.Type[0] : first.Type;
-                        options.push(parseUnionType(subType));
+                        choices.push(parseUnionType(subType, options));
                         continue;
                     }
                     if (subProps.every(isUnNamedProperty)) {
                         const tupleItems = subProps.map((p) => {
                             const subType = Array.isArray(p.Type) ? p.Type[0] : p.Type;
-                            return parseUnionType(subType);
+                            return parseUnionType(subType, options);
                         });
-                        options.push(b.tsTupleType(tupleItems));
+                        choices.push(b.tsTupleType(tupleItems));
                         continue;
                     }
-                    options.push(b.tsTypeLiteral(parseObjectType(subProps)));
+                    choices.push(b.tsTypeLiteral(parseObjectType(subProps, options)));
                 }
-                return b.tsUnionType(options);
+                return b.tsUnionType(choices);
             }
             if (prop.every(isUnNamedProperty)) {
                 const items = prop.map(p => {
                     const t = Array.isArray(p.Type) ? p.Type[0] : p.Type;
-                    return parseUnionType(t);
+                    return parseUnionType(t, options);
                 });
                 if (items.length === 1)
                     return items[0];
@@ -532,13 +586,13 @@ function parseUnionType(t) {
             if (prop.length === 1 && RECORD_KEY_TYPES.has(prop[0].Name)) {
                 return b.tsTypeReference(b.identifier('Record'), b.tsTypeParameterInstantiation([
                     NATIVE_TYPES[prop[0].Name],
-                    parseUnionType(prop[0].Type[0])
+                    parseUnionType(prop[0].Type[0], options)
                 ]));
             }
             /**
              * e.g. ?attributes: {*foo => text},
              */
-            return b.tsTypeLiteral(parseObjectType(t.Properties));
+            return b.tsTypeLiteral(parseObjectType(t.Properties, options));
         }
         else if (isNamedGroupReference(t)) {
             return b.tsTypeReference(b.identifier(pascalCase(t.Value)));

package/cli-examples/remote.ts

@@ -385,9 +385,9 @@ export interface BrowsingContextPrintParameters {
   shrinkToFit?: boolean;
 }
 
-export // Minimum size is 1pt x 1pt. Conversion follows from
+// Minimum size is 1pt x 1pt. Conversion follows from
 // https://www.w3.org/TR/css3-values/#absolute-lengths
-interface BrowsingContextPrintMarginParameters {
+export interface BrowsingContextPrintMarginParameters {
   /**
    * @default 1
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cddl2ts",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "A Node.js package that can generate a TypeScript definition based on a CDDL file",
   "author": "Christian Bromann <mail@bromann.dev>",
   "license": "MIT",
@@ -32,7 +32,7 @@
     "camelcase": "^9.0.0",
     "recast": "^0.23.11",
     "yargs": "^18.0.0",
-    "cddl": "0.19.1"
+    "cddl": "0.19.2"
   },
   "scripts": {
     "release": "release-it --config .release-it.ts --VV",

package/src/cli.ts

@@ -4,9 +4,11 @@ import yargs from 'yargs'
 
 import { parse } from 'cddl'
 
-import { transform } from './index.js'
+import { transform, type FieldCase } from './index.js'
 import { pkg } from './constants.js'
 
+const FIELD_CASE_CHOICES = ['camel', 'snake'] as const satisfies readonly FieldCase[]
+
 export default async function cli (argv = process.argv.slice(2)) {
     const parser = yargs(argv)
         .usage(`${pkg.name}\n${pkg.description}\n\nUsage:\nrunme2ts ./path/to/spec.cddl &> ./path/to/interface.ts`)
@@ -18,6 +20,12 @@ export default async function cli (argv = process.argv.slice(2)) {
             description: 'Use unknown instead of any',
             default: false
         })
+        .option('field-case', {
+            choices: FIELD_CASE_CHOICES,
+            type: 'string',
+            description: 'Case for generated interface fields',
+            default: 'camel'
+        })
         .help('help')
         .alias('h', 'help')
         .alias('v', 'version')
@@ -38,5 +46,8 @@ export default async function cli (argv = process.argv.slice(2)) {
     }
 
     const ast = parse(absoluteFilePath)
-    console.log(transform(ast, { useUnknown: args.u as boolean }))
+    console.log(transform(ast, {
+        useUnknown: args.u as boolean,
+        fieldCase: args.fieldCase as FieldCase
+    }))
 }

package/src/index.ts

@@ -59,13 +59,23 @@ const RECORD_KEY_TYPES = new Set([
 type ObjectEntry = types.namedTypes.TSCallSignatureDeclaration | types.namedTypes.TSConstructSignatureDeclaration | types.namedTypes.TSIndexSignature | types.namedTypes.TSMethodSignature | types.namedTypes.TSPropertySignature
 type ObjectBody = ObjectEntry[]
 type TSTypeKind = types.namedTypes.TSAsExpression['typeAnnotation']
+export type FieldCase = 'camel' | 'snake'
+type TransformSettings = Required<TransformOptions>
+const IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/
 
 export interface TransformOptions {
     useUnknown?: boolean
+    fieldCase?: FieldCase
 }
 
 export function transform (assignments: Assignment[], options?: TransformOptions) {
-    if (options?.useUnknown) {
+    const transformOptions: TransformSettings = {
+        useUnknown: false,
+        fieldCase: 'camel',
+        ...options
+    }
+
+    if (transformOptions.useUnknown) {
         NATIVE_TYPES.any = b.tsUnknownKeyword()
     } else {
         NATIVE_TYPES.any = b.tsAnyKeyword()
@@ -81,7 +91,7 @@ export function transform (assignments: Assignment[], options?: TransformOptions
     ) satisfies types.namedTypes.File
 
     for (const assignment of assignments) {
-        const statement = parseAssignment(assignment)
+        const statement = parseAssignment(assignment, transformOptions)
         if (!statement) {
             continue
         }
@@ -90,7 +100,51 @@ export function transform (assignments: Assignment[], options?: TransformOptions
     return print(ast).code
 }
 
-function parseAssignment (assignment: Assignment) {
+function getAssignmentComments (assignment: Assignment) {
+    return assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
+}
+
+function exportWithComments (
+    declaration: types.namedTypes.TSTypeAliasDeclaration
+        | types.namedTypes.TSInterfaceDeclaration
+) {
+    const expr = b.exportDeclaration(false, declaration)
+    expr.comments = declaration.comments
+    declaration.comments = []
+    return expr
+}
+
+function isExtensibleRecordProperty (prop: Property) {
+    return !isUnNamedProperty(prop) &&
+        prop.Occurrence.m === Infinity &&
+        !prop.HasCut &&
+        RECORD_KEY_TYPES.has(prop.Name)
+}
+
+function toSnakeCase (name: string) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+        .replace(/[^A-Za-z0-9_$]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toLowerCase()
+}
+
+function formatFieldName (name: string, fieldCase: FieldCase) {
+    return fieldCase === 'snake'
+        ? toSnakeCase(name)
+        : camelcase(name)
+}
+
+function createPropertyKey (name: string, options: TransformSettings) {
+    const fieldName = formatFieldName(name, options.fieldCase)
+    return IDENTIFIER_PATTERN.test(fieldName)
+        ? b.identifier(fieldName)
+        : b.stringLiteral(fieldName)
+}
+
+function parseAssignment (assignment: Assignment, options: TransformSettings) {
     if (isVariable(assignment)) {
         const propType = Array.isArray(assignment.PropertyType)
             ? assignment.PropertyType
@@ -103,12 +157,12 @@ function parseAssignment (assignment: Assignment) {
         if (propType.length === 1 && propType[0].Type === 'range') {
             typeParameters = b.tsNumberKeyword()
         } else {
-            typeParameters = b.tsUnionType(propType.map(parseUnionType))
+            typeParameters = b.tsUnionType(propType.map((prop) => parseUnionType(prop, options)))
         }
 
         const expr = b.tsTypeAliasDeclaration(id, typeParameters)
-        expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
-        return b.exportDeclaration(false, expr)
+        expr.comments = getAssignmentComments(assignment)
+        return exportWithComments(expr)
     }
 
     if (isGroup(assignment)) {
@@ -140,7 +194,7 @@ function parseAssignment (assignment: Assignment) {
                         i++ // Skip next property
                     }
 
-                    const options = choiceOptions.map(p => {
+                    const choiceTypes = choiceOptions.map(p => {
                         // If p is a group reference (Name ''), it's a TypeReference
                         // e.g. SessionAutodetectProxyConfiguration // SessionDirectProxyConfiguration
                         // The parser sometimes wraps it in an array, sometimes not (if inside a choice)
@@ -154,12 +208,12 @@ function parseAssignment (assignment: Assignment) {
                                    b.identifier(pascalCase(typeVal.Value || typeVal.Type))
                                )
                             }
-                            return parseUnionType(typeVal);
+                            return parseUnionType(typeVal, options)
                        }
                         // Otherwise it is an object literal with this property
-                        return b.tsTypeLiteral(parseObjectType([p]))
+                        return b.tsTypeLiteral(parseObjectType([p], options))
                     })
-                    intersections.push(b.tsUnionType(options))
+                    intersections.push(b.tsUnionType(choiceTypes))
                 } else {
                     staticProps.push(prop)
                 }
@@ -171,13 +225,13 @@ function parseAssignment (assignment: Assignment) {
                 const ownProps = staticProps.filter(p => !isUnNamedProperty(p))
 
                 if (ownProps.length > 0) {
-                    intersections.unshift(b.tsTypeLiteral(parseObjectType(ownProps)))
+                    intersections.unshift(b.tsTypeLiteral(parseObjectType(ownProps, options)))
                 }
 
                 for (const mixin of mixins) {
                     if (Array.isArray(mixin.Type) && mixin.Type.length > 1) {
-                         const options = mixin.Type.map(parseUnionType)
-                         intersections.push(b.tsUnionType(options))
+                         const choices = mixin.Type.map((type) => parseUnionType(type, options))
+                         intersections.push(b.tsUnionType(choices))
                     } else {
                         const typeVal = Array.isArray(mixin.Type) ? mixin.Type[0] : mixin.Type
                         if (isNamedGroupReference(typeVal)) {
@@ -201,8 +255,8 @@ function parseAssignment (assignment: Assignment) {
             }
 
             const expr = b.tsTypeAliasDeclaration(id, value)
-            expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
-            return b.exportDeclaration(false, expr)
+            expr.comments = getAssignmentComments(assignment)
+            return exportWithComments(expr)
         }
 
         const props = properties as Property[]
@@ -214,10 +268,10 @@ function parseAssignment (assignment: Assignment) {
             const prop = props[0]
             const propType = Array.isArray(prop.Type) ? prop.Type : [prop.Type]
             if (propType.length === 1 && RECORD_KEY_TYPES.has(prop.Name)) {
-                const value = parseUnionType(assignment)
+                const value = parseUnionType(assignment, options)
                 const expr = b.tsTypeAliasDeclaration(id, value)
-                expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
-                return b.exportDeclaration(false, expr)
+                expr.comments = getAssignmentComments(assignment)
+                return exportWithComments(expr)
             }
         }
 
@@ -263,10 +317,10 @@ function parseAssignment (assignment: Assignment) {
 
                     for (const prop of group.Properties) {
                         // Choices are wrapped in arrays in the properties
-                        const options = Array.isArray(prop) ? prop : [prop]
-                        if (options.length > 1) { // It's a choice within the mixin group
+                        const choiceProps = Array.isArray(prop) ? prop : [prop]
+                        if (choiceProps.length > 1) { // It's a choice within the mixin group
                             const unionOptions: any[] = []
-                            for (const option of options) {
+                            for (const option of choiceProps) {
                                 let refName: string | undefined
                                 const type = option.Type
                                 if (typeof type === 'string') refName = type
@@ -293,7 +347,7 @@ function parseAssignment (assignment: Assignment) {
                             }
                         }
 
-                        for (const option of options) {
+                        for (const option of choiceProps) {
                             let refName: string | undefined
                             const type = option.Type
 
@@ -374,7 +428,7 @@ function parseAssignment (assignment: Assignment) {
                                 }
                             } else if (type && typeof type === 'object') {
                                 if (isGroup(type) && Array.isArray(type.Properties)) {
-                                    choices.push(b.tsTypeLiteral(parseObjectType(type.Properties as Property[])))
+                                    choices.push(b.tsTypeLiteral(parseObjectType(type.Properties as Property[], options)))
                                     continue
                                 }
                                 refName = isNamedGroupReference(type)
@@ -420,7 +474,7 @@ function parseAssignment (assignment: Assignment) {
 
             const ownProps = props.filter(p => !isUnNamedProperty(p))
             if (ownProps.length > 0) {
-                 intersections.push(b.tsTypeLiteral(parseObjectType(ownProps)))
+                 intersections.push(b.tsTypeLiteral(parseObjectType(ownProps, options)))
             }
 
             let value: any
@@ -431,16 +485,16 @@ function parseAssignment (assignment: Assignment) {
             }
 
             const expr = b.tsTypeAliasDeclaration(id, value)
-            expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
-            return b.exportDeclaration(false, expr)
+            expr.comments = getAssignmentComments(assignment)
+            return exportWithComments(expr)
         }
 
         // Fallback to interface if no mixins (pure object)
-        const objectType = parseObjectType(props)
+        const objectType = parseObjectType(props, options)
 
         const expr = b.tsInterfaceDeclaration(id, b.tsInterfaceBody(objectType))
-        expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
-        return b.exportDeclaration(false, expr)
+        expr.comments = getAssignmentComments(assignment)
+        return exportWithComments(expr)
     }
 
     if (isCDDLArray(assignment)) {
@@ -455,21 +509,21 @@ function parseAssignment (assignment: Assignment) {
             // We need to parse each choice.
             const obj = assignmentValues.map((prop) => {
                  const t = Array.isArray(prop.Type) ? prop.Type[0] : prop.Type
-                 return parseUnionType(t)
+                 return parseUnionType(t, options)
             })
             const value = b.tsArrayType(b.tsParenthesizedType(b.tsUnionType(obj)))
             const expr = b.tsTypeAliasDeclaration(id, value)
-            expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
-            return b.exportDeclaration(false, expr)
+            expr.comments = getAssignmentComments(assignment)
+            return exportWithComments(expr)
         }
 
         // Standard array
         const firstType = assignmentValues.Type
         const obj = Array.isArray(firstType)
-            ? firstType.map(parseUnionType)
+            ? firstType.map((type) => parseUnionType(type, options))
             : isCDDLArray(firstType)
-                ? firstType.Values.map((val: any) => parseUnionType(Array.isArray(val.Type) ? val.Type[0] : val.Type))
-                : [parseUnionType(firstType)]
+                ? firstType.Values.map((val: any) => parseUnionType(Array.isArray(val.Type) ? val.Type[0] : val.Type, options))
+                : [parseUnionType(firstType, options)]
 
         const value = b.tsArrayType(
             obj.length === 1
@@ -477,14 +531,14 @@ function parseAssignment (assignment: Assignment) {
                 : b.tsParenthesizedType(b.tsUnionType(obj))
         )
         const expr = b.tsTypeAliasDeclaration(id, value)
-        expr.comments = assignment.Comments.map((c) => b.commentLine(` ${c.Content}`, true))
-        return b.exportDeclaration(false, expr)
+        expr.comments = getAssignmentComments(assignment)
+        return exportWithComments(expr)
     }
 
     throw new Error(`Unknown assignment type "${(assignment as any).Type}"`)
 }
 
-function parseObjectType (props: Property[]): ObjectBody {
+function parseObjectType (props: Property[], options: TransformSettings): ObjectBody {
     const propItems: ObjectBody = []
     for (const prop of props) {
         /**
@@ -502,10 +556,31 @@ function parseObjectType (props: Property[]): ObjectBody {
             continue
         }
 
-        const id = b.identifier(camelcase(prop.Name))
         const cddlType: PropertyType[] = Array.isArray(prop.Type) ? prop.Type : [prop.Type]
         const comments: string[] = prop.Comments.map((c) => ` ${c.Content}`)
 
+        if (isExtensibleRecordProperty(prop)) {
+            const keyIdentifier = b.identifier('key')
+            keyIdentifier.typeAnnotation = b.tsTypeAnnotation(NATIVE_TYPES[prop.Name])
+
+            const indexSignature = b.tsIndexSignature(
+                [keyIdentifier],
+                b.tsTypeAnnotation(
+                    b.tsUnionType([
+                        ...cddlType.map((t) => parseUnionType(t, options)),
+                        b.tsUndefinedKeyword()
+                    ])
+                )
+            )
+            indexSignature.comments = comments.length
+                ? [b.commentBlock(`*\n *${comments.join('\n *')}\n `)]
+                : []
+            propItems.push(indexSignature)
+            continue
+        }
+
+        const id = createPropertyKey(prop.Name, options)
+
         if (prop.Operator && prop.Operator.Type === 'default') {
             const defaultValue = parseDefaultValue(prop.Operator)
             defaultValue && comments.length && comments.push('') // add empty line if we have previous comments
@@ -513,7 +588,7 @@ function parseObjectType (props: Property[]): ObjectBody {
         }
 
         const type = cddlType.map((t) => {
-            const unionType = parseUnionType(t)
+            const unionType = parseUnionType(t, options)
             if (unionType) {
                 const defaultValue = parseDefaultValue((t as PropertyReference).Operator)
                 defaultValue && comments.length && comments.push('') // add empty line if we have previous comments
@@ -535,7 +610,7 @@ function parseObjectType (props: Property[]): ObjectBody {
     return propItems
 }
 
-function parseUnionType (t: PropertyType | Assignment): TSTypeKind {
+function parseUnionType (t: PropertyType | Assignment, options: TransformSettings): TSTypeKind {
     if (typeof t === 'string') {
         if (!NATIVE_TYPES[t]) {
             throw new Error(`Unknown native type: "${t}`)
@@ -558,35 +633,35 @@ function parseUnionType (t: PropertyType | Assignment): TSTypeKind {
              * Check if we have choices in the group (arrays of Properties)
              */
             if (prop.some(p => Array.isArray(p))) {
-                const options: TSTypeKind[] = []
+                const choices: TSTypeKind[] = []
                 for (const choice of prop) {
                     const subProps = Array.isArray(choice) ? choice : [choice]
 
                     if (subProps.length === 1 && isUnNamedProperty(subProps[0])) {
                         const first = subProps[0]
                         const subType = Array.isArray(first.Type) ? first.Type[0] : first.Type
-                        options.push(parseUnionType(subType as PropertyType))
+                        choices.push(parseUnionType(subType as PropertyType, options))
                         continue
                     }
 
                     if (subProps.every(isUnNamedProperty)) {
                         const tupleItems = subProps.map((p) => {
                             const subType = Array.isArray(p.Type) ? p.Type[0] : p.Type
-                            return parseUnionType(subType as PropertyType)
+                            return parseUnionType(subType as PropertyType, options)
                         })
-                        options.push(b.tsTupleType(tupleItems))
+                        choices.push(b.tsTupleType(tupleItems))
                         continue
                     }
 
-                    options.push(b.tsTypeLiteral(parseObjectType(subProps)))
+                    choices.push(b.tsTypeLiteral(parseObjectType(subProps, options)))
                 }
-                return b.tsUnionType(options)
+                return b.tsUnionType(choices)
             }
 
             if ((prop as Property[]).every(isUnNamedProperty)) {
                  const items = (prop as Property[]).map(p => {
                        const t = Array.isArray(p.Type) ? p.Type[0] : p.Type
-                       return parseUnionType(t as PropertyType)
+                       return parseUnionType(t as PropertyType, options)
                  })
 
                  if (items.length === 1) return items[0];
@@ -601,7 +676,7 @@ function parseUnionType (t: PropertyType | Assignment): TSTypeKind {
                     b.identifier('Record'),
                     b.tsTypeParameterInstantiation([
                         NATIVE_TYPES[(prop[0] as Property).Name],
-                        parseUnionType(((prop[0] as Property).Type as PropertyType[])[0])
+                        parseUnionType(((prop[0] as Property).Type as PropertyType[])[0], options)
                     ])
                 )
             }
@@ -609,7 +684,7 @@ function parseUnionType (t: PropertyType | Assignment): TSTypeKind {
             /**
              * e.g. ?attributes: {*foo => text},
              */
-            return b.tsTypeLiteral(parseObjectType(t.Properties as Property[]))
+            return b.tsTypeLiteral(parseObjectType(t.Properties as Property[], options))
         } else if (isNamedGroupReference(t)) {
             return b.tsTypeReference(
                 b.identifier(pascalCase(t.Value))

package/tests/__snapshots__/extensible_metadata.test.ts.snap

@@ -0,0 +1,16 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`extensible metadata > should render extensible metadata as an interface with an index signature 1`] = `
+"export type MetadataScalar = null | boolean | number | number | string;
+
+export interface MessageMetadata {
+  provider?: string;
+  model?: string;
+  modelType?: string;
+  runId?: string;
+  threadId?: string;
+  systemFingerprint?: string;
+  serviceTier?: string;
+  [key: string]: MetadataScalar | undefined;
+}"
+`;

package/tests/__snapshots__/group_choice.test.ts.snap

@@ -12,52 +12,52 @@ export type DirectProxyConfiguration = Extensible & {
   proxyType: "direct";
 };
 
-export // 1. Simple Group Choice
-type ManualProxyConfiguration = Extensible & {
+// 1. Simple Group Choice
+export type ManualProxyConfiguration = Extensible & {
   proxyType: "manual";
 };
 
-export // 2. Nested Group Choice
-type SimpleGroupChoice = Int | string;
+// 2. Nested Group Choice
+export type SimpleGroupChoice = Int | string;
 
-export // 3. Group Choice with Multiple Items (Sequence) - interpreted as tuple
-type NestedGroupChoice = (Int | Tstr);
+// 3. Group Choice with Multiple Items (Sequence) - interpreted as tuple
+export type NestedGroupChoice = (Int | Tstr);
 
-export // 4. Map Group Choice - interpreted as map (interface) union
-type SequenceGroupChoice = [number, string] | number;
+// 4. Map Group Choice - interpreted as map (interface) union
+export type SequenceGroupChoice = [number, string] | number;
 
-export // 5. Type Choice inside Group - should be value union
-type MapGroupChoice = {
+// 5. Type Choice inside Group - should be value union
+export type MapGroupChoice = {
   a: 1;
 } | {
   b: 2;
 };
 
-export // 6. Array with Group Choice - should be array of union?
-type TypeChoiceInsideGroup = number | string;
+// 6. Array with Group Choice - should be array of union?
+export type TypeChoiceInsideGroup = number | string;
 
-export // 7. Map with nested group (bare and parens) - should be object like
-type ArrayGroupChoice = Int | string[];
+// 7. Map with nested group (bare and parens) - should be object like
+export type ArrayGroupChoice = Int | string[];
 
 export type MapWithBareGroup = number;
 
-export // 8. Group wrapped in map with multiple properties
-type MapWithParensGroup = number;
+// 8. Group wrapped in map with multiple properties
+export type MapWithParensGroup = number;
 
-export // 9. Property type choice without operators
-type MapGroupWrap = ;
+// 9. Property type choice without operators
+export type MapGroupWrap = ;
 
-export // 10. Nested choice with group reference
-interface PropChoiceNoOp {
+// 10. Nested choice with group reference
+export interface PropChoiceNoOp {
   a: number | number;
   b: string;
 }
 
-export // 11. Complex type (group) followed by property without comma
-type NestedChoiceRef = number | string;
+// 11. Complex type (group) followed by property without comma
+export type NestedChoiceRef = number | string;
 
-export // 12. Multi-item group choice (verifies isChoice persistence)
-interface MapNoComma {
+// 12. Multi-item group choice (verifies isChoice persistence)
+export interface MapNoComma {
   a: number;
   b: string;
 }

package/tests/__snapshots__/mod.test.ts.snap

@@ -95,8 +95,8 @@ export interface SomeGroup {
 export type ScriptListLocalValue = ScriptLocalValue[];
 export type ScriptMappingLocalValue = (ScriptLocalValue | ScriptLocalValue)[];
 
-export // some comments here
-type Extensible = Record<string, any>;",
+// some comments here
+export type Extensible = Record<string, any>;",
   ],
 ]
 `;

package/tests/__snapshots__/webdriver_remote.test.ts.snap

@@ -388,9 +388,9 @@ export interface BrowsingContextPrintParameters {
   shrinkToFit?: boolean;
 }
 
-export // Minimum size is 1pt x 1pt. Conversion follows from
+// Minimum size is 1pt x 1pt. Conversion follows from
 // https://www.w3.org/TR/css3-values/#absolute-lengths
-interface BrowsingContextPrintMarginParameters {
+export interface BrowsingContextPrintMarginParameters {
   /**
    * @default 1
    */

package/tests/extensible_metadata.test.ts

@@ -0,0 +1,49 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import cli from '../src/cli.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const cddlFile = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'extensible_metadata.cddl')
+
+vi.mock('../src/constants', () => ({
+    pkg: {
+        name: 'cddl2ts',
+        version: '0.0.0'
+    }
+}))
+
+describe('extensible metadata', () => {
+    let exitOrig = process.exit
+    let logOrig = console.log
+    let errorOrig = console.error
+
+    beforeEach(() => {
+        process.exit = vi.fn() as any
+        console.log = vi.fn()
+        console.error = vi.fn()
+    })
+
+    afterEach(() => {
+        process.exit = exitOrig
+        console.log = logOrig
+        console.error = errorOrig
+    })
+
+    it('should render extensible metadata as an interface with an index signature', async () => {
+        await cli([cddlFile])
+
+        expect(process.exit).not.toHaveBeenCalledWith(1)
+        expect(console.error).not.toHaveBeenCalled()
+
+        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
+
+        expect(output).toContain('export interface MessageMetadata {')
+        expect(output).toContain('provider?: string;')
+        expect(output).toContain('modelType?: string;')
+        expect(output).toContain('[key: string]: MetadataScalar | undefined;')
+        expect(output).not.toContain('text?: MetadataScalar;')
+        expect(output).toMatchSnapshot()
+    })
+})

package/tests/mod.test.ts

@@ -66,6 +66,23 @@ describe('cddl2ts', () => {
         expect(process.exit).toHaveBeenCalledTimes(0)
     })
 
+    it('should allow configuring snake_case fields from the CLI', async () => {
+        await cli([
+            path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'test.cddl'),
+            '--field-case',
+            'snake'
+        ])
+
+        expect(console.log).toHaveBeenCalledTimes(1)
+        const output = vi.mocked(console.log).mock.calls[0]?.[0] as string
+        expect(output).toContain('export interface SessionCapabilitiesRequest {')
+        expect(output).toContain('always_match?: SessionCapabilityRequest;')
+        expect(output).toContain('first_match?: SessionCapabilityRequest[];')
+        expect(output).toContain('pointer_type?: InputPointerType;')
+        expect(output).not.toContain('alwaysMatch?: SessionCapabilityRequest;')
+        expect(process.exit).toHaveBeenCalledTimes(0)
+    })
+
     afterEach(() => {
         process.exit = exitOrig
         console.log = logOrig

package/tests/named_group_choice.test.ts

@@ -39,8 +39,8 @@ describe('named group choice', () => {
 
         const output = vi.mocked(console.log).mock.calls.flat().join('\n')
 
-        // The export keyword is separated from the type definition by comments
-        expect(output).toMatch(/export\s+(\/\/.*\n)+\s*type Choice = OptionA \| OptionB/)
+        // Leading comments should render before the exported declaration.
+        expect(output).toMatch(/(\/\/.*\n)+export type Choice = OptionA \| OptionB/)
         expect(output).toContain('export interface OptionA {')
         expect(output).toContain('export interface OptionB {')
     })

package/tests/transform_edge_cases.test.ts

@@ -14,11 +14,11 @@ import { transform } from '../src/index.js'
 
 const COMMENTS: Comment[] = []
 
-function comment (content: string): Comment {
+function comment (content: string, leading = false): Comment {
     return {
         Type: 'comment',
         Content: content,
-        Leading: false
+        Leading: leading
     }
 }
 
@@ -123,6 +123,35 @@ describe('transform edge cases', () => {
         expect(output).toContain('export type MaybeValue = unknown;')
     })
 
+    it('should keep camelCase fields by default', () => {
+        const output = transform([
+            group('session-capability-request', [
+                property('page_ranges', 'tstr')
+            ])
+        ])
+
+        expect(output).toContain('export interface SessionCapabilityRequest {')
+        expect(output).toContain('pageRanges: string;')
+    })
+
+    it('should support snake_case fields without changing exported type names', () => {
+        const output = transform([
+            group('session-capability-request', [
+                property('acceptInsecureCerts', 'bool'),
+                property('pageRanges', 'tstr'),
+                property('nestedConfig', group('', [
+                    property('requestId', 'uint')
+                ]))
+            ])
+        ], { fieldCase: 'snake' })
+
+        expect(output).toContain('export interface SessionCapabilityRequest {')
+        expect(output).toContain('accept_insecure_certs: boolean;')
+        expect(output).toContain('page_ranges: string;')
+        expect(output).toContain('nested_config: {')
+        expect(output).toContain('request_id: number;')
+    })
+
     it('should generate intersections for choices with static props and mixins', () => {
         const output = transform([
             group('combined', [
@@ -240,6 +269,40 @@ describe('transform edge cases', () => {
         expect(output).toContain('enabled?: boolean')
     })
 
+    it('should place leading comments before exported declarations', () => {
+        const output = transform([
+            variable('metadata-scalar', ['null', 'bool', 'int', 'float', 'text'], [
+                comment('Flat scalar value used by concise metadata bags.', true)
+            ])
+        ])
+
+        expect(output).toContain(`// Flat scalar value used by concise metadata bags.\nexport type MetadataScalar = null | boolean | number | number | string;`)
+        expect(output).not.toContain('export // Flat scalar value used by concise metadata bags.')
+    })
+
+    it('should emit extensible object properties as index signatures', () => {
+        const output = transform([
+            variable('metadata-scalar', ['null', 'bool', 'int', 'float', 'text']),
+            group('message-metadata', [
+                property('provider', 'text', {
+                    Occurrence: { n: 0, m: 1 }
+                }),
+                property('model', 'text', {
+                    Occurrence: { n: 0, m: 1 }
+                }),
+                property('text', groupRef('metadata-scalar'), {
+                    Occurrence: { n: 0, m: Infinity }
+                })
+            ])
+        ])
+
+        expect(output).toContain('export interface MessageMetadata {')
+        expect(output).toContain('provider?: string;')
+        expect(output).toContain('model?: string;')
+        expect(output).toContain('[key: string]: MetadataScalar | undefined;')
+        expect(output).not.toContain('text?: MetadataScalar;')
+    })
+
     it('should throw clear errors for unsupported inputs', () => {
         expect(() => transform([
             variable('unknown-native', 'nope')