@contractkit/prettier-plugin 0.12.1 → 0.13.0

package/src/print-contract.ts

@@ -4,6 +4,16 @@ import { INDENT } from './indent.js';
 
 // ─── Model declaration ───────────────────────────────────────────────────────
 
+/**
+ * Render a `contract` body from its `Name: ...` onward (the `contract ` keyword and any
+ * doc comment written above the declaration are prepended by the caller). Handles both the
+ * type-alias form (`Name: <type>`) and the regular field-block form, including modifiers,
+ * base chain, and per-field printing. Any `model.trailingComments` (comments after the last
+ * field, before `}`) are emitted as indented `# text` lines so they round-trip.
+ *
+ * `model.description` is emitted here only when `model.descriptionInline` says the author wrote
+ * it on the header line; otherwise it belongs above the declaration and the caller emits it.
+ */
 export function printModelDecl(model: ModelNode, printWidth: number = 80): string {
     // Type alias form: Name : typeExpression
     if (model.type !== undefined) {
@@ -11,7 +21,9 @@ export function printModelDecl(model: ModelNode, printWidth: number = 80): strin
     }
 
     // Regular model with fields (possibly inherited)
-    const commentSuffix = model.description ? ` # ${model.description}` : '';
+    // A doc comment written above the declaration is re-emitted there by the caller; only an
+    // inline one belongs on the header line.
+    const commentSuffix = model.description && model.descriptionInline ? ` # ${model.description}` : '';
     const modifiers = [
         model.deprecated ? 'deprecated' : '',
         model.inputCase || model.outputCase
@@ -29,13 +41,18 @@ export function printModelDecl(model: ModelNode, printWidth: number = 80): strin
     for (const field of model.fields) {
         lines.push(printField(field, INDENT, printWidth));
     }
+    for (const comment of model.trailingComments ?? []) {
+        lines.push(`${INDENT}# ${comment}`);
+    }
     lines.push('}');
     return lines.join('\n');
 }
 
 function printTypeAlias(model: ModelNode, printWidth: number): string {
     const type = model.type!;
-    const commentSuffix = model.description ? ` # ${model.description}` : '';
+    // A doc comment written above the declaration is re-emitted there by the caller; only an
+    // inline one belongs on the header line.
+    const commentSuffix = model.description && model.descriptionInline ? ` # ${model.description}` : '';
     const modifiers = [
         model.deprecated ? 'deprecated' : '',
         model.inputCase || model.outputCase

package/src/print-operation.ts

@@ -8,6 +8,8 @@ import type {
     ContractTypeNode,
     ObjectMode,
     PluginValue,
+    McpConfigNode,
+    OpBodyKey,
 } from '@contractkit/core';
 import { SECURITY_NONE } from '@contractkit/core';
 import { printType, formatDefault } from './print-type.js';
@@ -21,6 +23,7 @@ const I4 = INDENT.repeat(4);
 // ─── Orphan comment helpers ──────────────────────────────────────────────────
 
 type CommentEntry = { line: number; text: string };
+/** A run of consecutive-line orphan comments, keyed by the source line it starts on. */
 export type CommentBlock = { startLine: number; lines: string[] };
 
 /** Group sorted orphan comment entries into consecutive-line blocks. */
@@ -52,10 +55,21 @@ export function flushBlocks(out: string[], blocks: CommentBlock[], idx: { value:
 
 // ─── Route ───────────────────────────────────────────────────────────────────
 
+/**
+ * Render an `operation` route body from its `path: {` onward (the `operation` keyword, any
+ * modifier, and the route's leading comments are prepended by the caller). Emits the
+ * params/security blocks and each HTTP operation, interleaving orphan comment `blocks` at their
+ * original source positions — `idx` tracks how far through `blocks` we've consumed, and
+ * `nextRouteStart` bounds the flush to comments before the following route. Any
+ * `route.trailingComments` (comments after the last operation, before `}`) are emitted before
+ * the closing brace so they round-trip.
+ *
+ * Blank lines between operations come from each operation's `blankLineBefore`, so the author's
+ * spacing survives rather than being normalized to one rule or the other.
+ */
 export function printRoute(route: OpRouteNode, blocks: CommentBlock[], idx: { value: number }, nextRouteStart: number): string {
     const lines: string[] = [];
-    const commentSuffix = route.description ? ` # ${route.description}` : '';
-    lines.push(`${route.path}: {${commentSuffix}`);
+    lines.push(`${route.path}: {`);
 
     if (route.params !== undefined) {
         lines.push(...printParamsBlock(route.params, I1, route.paramsMode));
@@ -66,6 +80,8 @@ export function printRoute(route: OpRouteNode, blocks: CommentBlock[], idx: { va
     }
 
     for (const op of route.operations) {
+        // Reproduce the author's spacing rather than imposing our own.
+        if (op.blankLineBefore && lines.length > 1) lines.push('');
         // Flush comment blocks that appear before this operation (inside the route)
         flushBlocks(lines, blocks, idx, op.loc.line, I1);
         lines.push(...printOperation(op));
@@ -74,6 +90,11 @@ export function printRoute(route: OpRouteNode, blocks: CommentBlock[], idx: { va
     // Flush comment blocks between last operation and the next route
     flushBlocks(lines, blocks, idx, nextRouteStart, I1);
 
+    // Trailing/orphan comments after the last operation, before the closing brace.
+    for (const comment of route.trailingComments ?? []) {
+        lines.push(`${I1}# ${comment}`);
+    }
+
     lines.push('}');
     return lines.join('\n');
 }
@@ -105,55 +126,114 @@ function printParamsBlock(source: ParamSource, indent: string, mode?: ObjectMode
 
 // ─── HTTP operation ──────────────────────────────────────────────────────────
 
-function printOperation(op: OpOperationNode): string[] {
-    const lines: string[] = [];
-    const commentSuffix = op.description ? ` # ${op.description}` : '';
-    const modPart = op.modifiers?.length ? `(${op.modifiers[0]})` : '';
-    lines.push(`${I1}${op.method}${modPart}: {${commentSuffix}`);
-
-    if (op.name) lines.push(`${I2}name: ${op.name}`);
-    if (op.service) lines.push(`${I2}service: ${op.service}`);
-    if (op.sdk) lines.push(`${I2}sdk: ${op.sdk}`);
-    if (op.signature) {
-        const comment = op.signatureDescription ? ` # ${op.signatureDescription}` : '';
-        if (op.signaturePolicy) {
-            lines.push(`${I2}signature: {`);
-            lines.push(`${I3}options: ${formatSignatureValue(op.signature)}${comment}`);
-            lines.push(`${I3}policy: ${op.signaturePolicy}`);
+/** Order the body keys are emitted in when the node carries no source order (built programmatically). */
+const CANONICAL_KEY_ORDER: OpBodyKey[] = ['name', 'service', 'sdk', 'mcp', 'signature', 'security', 'plugins', 'query', 'headers', 'request', 'responses'];
+
+/** Render a single operation-body key. Returns `[]` when the operation doesn't carry that key. */
+function printOperationKey(op: OpOperationNode, key: OpBodyKey): string[] {
+    switch (key) {
+        case 'name':
+            return op.name ? [`${I2}name: ${op.name}`] : [];
+        case 'service':
+            return op.service ? [`${I2}service: ${op.service}`] : [];
+        case 'sdk':
+            return op.sdk ? [`${I2}sdk: ${op.sdk}`] : [];
+        case 'mcp':
+            if (op.mcp === true) return [`${I2}mcp: true`];
+            if (op.mcp === false) return [`${I2}mcp: false`];
+            return op.mcp ? printMcpBlock(op.mcp) : [];
+        case 'signature': {
+            if (!op.signature) return [];
+            const comment = op.signatureDescription ? ` # ${op.signatureDescription}` : '';
+            if (op.signaturePolicy) {
+                return [
+                    `${I2}signature: {`,
+                    `${I3}options: ${formatSignatureValue(op.signature)}${comment}`,
+                    `${I3}policy: ${op.signaturePolicy}`,
+                    `${I2}}`,
+                ];
+            }
+            return [`${I2}signature: ${formatSignatureValue(op.signature)}${comment}`];
+        }
+        case 'security':
+            return op.security !== undefined ? printSecurity(op.security) : [];
+        case 'plugins': {
+            if (!op.plugins || Object.keys(op.plugins).length === 0) return [];
+            const lines = [`${I2}plugins: {`];
+            for (const [k, val] of Object.entries(op.plugins)) lines.push(...printPluginEntry(k, val, I3));
             lines.push(`${I2}}`);
-        } else {
-            lines.push(`${I2}signature: ${formatSignatureValue(op.signature)}${comment}`);
+            return lines;
         }
-    }
-    if (op.security !== undefined) lines.push(...printSecurity(op.security));
-    if (op.plugins && Object.keys(op.plugins).length > 0) {
-        lines.push(`${I2}plugins: {`);
-        for (const [key, val] of Object.entries(op.plugins)) {
-            lines.push(...printPluginEntry(key, val, I3));
+        case 'query':
+            return op.query !== undefined ? printQueryOrHeaders('query', op.query, op.queryMode) : [];
+        case 'headers':
+            if (op.requestHeadersOptOut) return [`${I2}headers: none`];
+            return op.headers !== undefined ? printQueryOrHeaders('headers', op.headers, op.headersMode) : [];
+        case 'request': {
+            if (!op.request) return [];
+            const lines = [`${I2}request: {`];
+            for (const body of op.request.bodies) lines.push(...printContentTypeLine(body.contentType, body.bodyType, I3));
+            lines.push(`${I2}}`);
+            return lines;
         }
-        lines.push(`${I2}}`);
+        case 'responses':
+            return op.responses.length > 0 ? printResponseBlock(op.responses) : [];
     }
-    if (op.query !== undefined) lines.push(...printQueryOrHeaders('query', op.query, op.queryMode));
-    if (op.requestHeadersOptOut) {
-        lines.push(`${I2}headers: none`);
-    } else if (op.headers !== undefined) {
-        lines.push(...printQueryOrHeaders('headers', op.headers, op.headersMode));
-    }
-    if (op.request) {
-        lines.push(`${I2}request: {`);
-        for (const body of op.request.bodies) {
-            lines.push(...printContentTypeLine(body.contentType, body.bodyType, I3));
-        }
-        lines.push(`${I2}}`);
+}
+
+function printOperation(op: OpOperationNode): string[] {
+    const lines: string[] = [];
+    const modPart = op.modifiers?.length ? `(${op.modifiers[0]})` : '';
+
+    // A doc comment written above the method line goes back above it; only an inline one is
+    // re-emitted as a trailing `#` on the header. Nodes built programmatically carry no placement,
+    // and default to inline — the form most `.ck` sources use and one that round-trips as written.
+    const inlineDescription = op.descriptionInline ?? true;
+    if (op.description && !inlineDescription) {
+        for (const line of op.description.split('\n')) lines.push(`${I1}# ${line}`);
     }
-    if (op.responses.length > 0) {
-        lines.push(...printResponseBlock(op.responses));
+    const commentSuffix = op.description && inlineDescription ? ` # ${op.description}` : '';
+    lines.push(`${I1}${op.method}${modPart}: {${commentSuffix}`);
+
+    // Emit in source order when the parser recorded it, so formatting never reorders a user's keys.
+    // Any key the source order doesn't mention (e.g. added by a later AST pass) follows in canonical order.
+    const order = op.keyOrder ?? [];
+    const rest = CANONICAL_KEY_ORDER.filter(k => !order.includes(k));
+    for (const key of [...order, ...rest]) {
+        lines.push(...printOperationKey(op, key));
     }
 
     lines.push(`${I1}}`);
     return lines;
 }
 
+// ─── MCP block ───────────────────────────────────────────────────────────────
+
+/**
+ * Reconstruct the `hint:` token list from the four annotation booleans, in canonical
+ * order. Each set boolean contributes its positive or negative token; unset hints are omitted.
+ */
+function mcpHintTokens(mcp: McpConfigNode): string[] {
+    const tokens: string[] = [];
+    if (mcp.readOnlyHint !== undefined) tokens.push(mcp.readOnlyHint ? 'readOnly' : 'nonReadOnly');
+    if (mcp.idempotentHint !== undefined) tokens.push(mcp.idempotentHint ? 'idempotent' : 'nonIdempotent');
+    if (mcp.destructiveHint !== undefined) tokens.push(mcp.destructiveHint ? 'destructive' : 'nonDestructive');
+    if (mcp.openWorldHint !== undefined) tokens.push(mcp.openWorldHint ? 'openWorld' : 'closedWorld');
+    return tokens;
+}
+
+/** Print an `mcp: { ... }` settings block. Fields are emitted in canonical order; `hint:` is omitted when no hints are set. */
+function printMcpBlock(mcp: McpConfigNode): string[] {
+    const lines: string[] = [`${I2}mcp: {`];
+    if (mcp.name !== undefined) lines.push(`${I3}name: "${escapeString(mcp.name)}"`);
+    if (mcp.title !== undefined) lines.push(`${I3}title: "${escapeString(mcp.title)}"`);
+    if (mcp.description !== undefined) lines.push(`${I3}description: "${escapeString(mcp.description)}"`);
+    const tokens = mcpHintTokens(mcp);
+    if (tokens.length > 0) lines.push(`${I3}hint: ${tokens.join(', ')}`);
+    lines.push(`${I2}}`);
+    return lines;
+}
+
 // ─── Plugins block ───────────────────────────────────────────────────────────
 
 const IDENT_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
@@ -304,7 +384,10 @@ function printResponseBlock(responses: OpResponseNode[]): string[] {
         const hasBody = resp.contentType && resp.bodyType;
         const hasHeaders = resp.headers && resp.headers.length > 0;
         const optOut = resp.headersOptOut;
-        if (hasBody || hasHeaders || optOut) {
+        if (resp.inline && hasBody && !hasHeaders && !optOut && resp.bodyType!.kind !== 'inlineObject') {
+            // Written on one line in the source, so keep it there: `200: { application/json: Pet }`.
+            lines.push(`${I3}${resp.statusCode}: { ${resp.contentType}: ${printType(resp.bodyType!)} }`);
+        } else if (hasBody || hasHeaders || optOut) {
             lines.push(`${I3}${resp.statusCode}: {`);
             if (hasBody) {
                 lines.push(...printContentTypeLine(resp.contentType!, resp.bodyType!, I4));

package/src/print-type.ts

@@ -105,9 +105,15 @@ export function printField(field: FieldNode, indent: string, printWidth: number
     return fullLine;
 }
 
-/** Print inline-object fields expanded (used when an inline brace object trails a type alias). */
+/** Print inline-object fields expanded (used when an inline brace object trails a type alias).
+ * Any `trailingComments` (comments after the last field, before `}`) are emitted as indented
+ * `# text` lines after the fields, matching how model bodies round-trip trailing comments. */
 export function printInlineObjectExpanded(obj: InlineObjectTypeNode, indent: string, printWidth: number = 80): string[] {
-    return obj.fields.map(f => printField(f, indent, printWidth));
+    const lines = obj.fields.map(f => printField(f, indent, printWidth));
+    for (const comment of obj.trailingComments ?? []) {
+        lines.push(`${indent}# ${comment}`);
+    }
+    return lines;
 }
 
 // ─── Helpers ────────────────────────────────────────────────────────────────

package/tests/print-ck.test.ts

@@ -60,7 +60,9 @@ describe('printCk — route modifiers', () => {
 
     it('preserves description alongside modifier', () => {
         const ast = makeRoot([makeRoute('/users', [makeOp('get')], { modifiers: ['deprecated'], description: 'Old user list' })]);
-        expect(printCk(ast)).toContain('operation(deprecated) /users: { # Old user list');
+        // A route description is emitted above the declaration, not inline: a `#` after the `{`
+        // would re-parse as the first operation's description instead.
+        expect(printCk(ast)).toContain('# Old user list\noperation(deprecated) /users: {');
     });
 });
 
@@ -531,6 +533,82 @@ describe('printCk — response headers', () => {
     });
 });
 
+describe('printCk — mcp field', () => {
+    function roundTrip(source: string): string {
+        const diag = new DiagnosticCollector();
+        const ast = parseCk(source, 'test.ck', diag);
+        expect(diag.hasErrors()).toBe(false);
+        return printCk(ast);
+    }
+
+    it('prints mcp: true', () => {
+        const ast = makeRoot([makeRoute('/users', [makeOp('get', { mcp: true })])]);
+        expect(printCk(ast)).toContain('        mcp: true');
+    });
+
+    it('prints explicit mcp: false', () => {
+        const ast = makeRoot([makeRoute('/users', [makeOp('get', { mcp: false })])]);
+        expect(printCk(ast)).toContain('        mcp: false');
+    });
+
+    it('omits mcp when undefined', () => {
+        const ast = makeRoot([makeRoute('/users', [makeOp('get')])]);
+        expect(printCk(ast)).not.toContain('mcp:');
+    });
+
+    it('prints mcp block with text fields and reconstructed hint list', () => {
+        const ast = makeRoot([
+            makeRoute('/routes', [
+                makeOp('post', {
+                    mcp: {
+                        name: 'searchRoutes',
+                        title: 'Search routes',
+                        description: 'Full-text search.',
+                        readOnlyHint: true,
+                        idempotentHint: true,
+                        destructiveHint: false,
+                        loc: makeLoc(),
+                    },
+                }),
+            ]),
+        ]);
+        const out = printCk(ast);
+        expect(out).toContain('        mcp: {');
+        expect(out).toContain('            name: "searchRoutes"');
+        expect(out).toContain('            title: "Search routes"');
+        expect(out).toContain('            description: "Full-text search."');
+        expect(out).toContain('            hint: readOnly, idempotent, nonDestructive');
+    });
+
+    it('round-trips mcp: true / false through parse', () => {
+        expect(roundTrip('operation /a: {\n    get: {\n        mcp: true\n    }\n}\n')).toContain('        mcp: true');
+        expect(roundTrip('operation /b: {\n    get: {\n        mcp: false\n    }\n}\n')).toContain('        mcp: false');
+    });
+
+    it('round-trips an mcp settings block through parse', () => {
+        const source = `\
+operation /routes: {
+    post: {
+        mcp: {
+            name: "searchRoutes"
+            title: "Search routes"
+            description: "Full-text search across routes."
+            hint: readOnly, idempotent, nonDestructive, closedWorld
+        }
+    }
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('        mcp: {');
+        expect(out).toContain('            name: "searchRoutes"');
+        expect(out).toContain('            hint: readOnly, idempotent, nonDestructive, closedWorld');
+        // Idempotent: printing the round-tripped output again is stable.
+        const diag = new DiagnosticCollector();
+        expect(printCk(parseCk(out, 'test.ck', diag))).toBe(out);
+        expect(diag.hasErrors()).toBe(false);
+    });
+});
+
 describe('printCk — options-level header globals (round-trip)', () => {
     function roundTrip(source: string): string {
         const diag = new DiagnosticCollector();
@@ -800,3 +878,242 @@ contract M: {
         expect(roundTrip(source)).toBe(source);
     });
 });
+
+describe('printCk — trailing/orphan comments (round-trip)', () => {
+    function roundTrip(source: string): string {
+        const diag = new DiagnosticCollector();
+        const ast = parseCk(source, 'test.ck', diag);
+        expect(diag.hasErrors()).toBe(false);
+        return printCk(ast);
+    }
+
+    it('preserves a comment on the last line of a contract body', () => {
+        const source = `\
+contract Payment: {
+    id: uuid
+    # more fields to come
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('# more fields to come');
+        // Comment sits on its own line after the last field, before the closing brace.
+        expect(out).toBe(source);
+        // Idempotent: formatting the output again yields the same result.
+        expect(roundTrip(out)).toBe(out);
+    });
+
+    it('preserves multiple trailing comments in a contract body', () => {
+        const source = `\
+contract Payment: {
+    id: uuid
+    # note one
+    # note two
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('# note one');
+        expect(out).toContain('# note two');
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+
+    it('preserves a comment as the only content of a contract body', () => {
+        const source = `\
+contract Empty: {
+    # nothing here yet
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('# nothing here yet');
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+
+    it('preserves a comment on the last line of an operation/route body', () => {
+        const source = `\
+operation /users: {
+    get: {
+    }
+    # TODO: add post
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('# TODO: add post');
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+
+    it('does not double-emit a header inline comment on a contract with no fields', () => {
+        const source = `\
+contract Empty: { # nothing here yet
+}
+`;
+        const out = roundTrip(source);
+        // The inline header comment must survive exactly once, not be duplicated on a trailing line.
+        expect(out.match(/# nothing here yet/g)?.length).toBe(1);
+        expect(roundTrip(out)).toBe(out);
+    });
+});
+
+describe('printCk — inline object trailing comments (round-trip)', () => {
+    function roundTrip(source: string): string {
+        const diag = new DiagnosticCollector();
+        const ast = parseCk(source, 'test.ck', diag);
+        expect(diag.hasErrors()).toBe(false);
+        return printCk(ast);
+    }
+
+    it('preserves a trailing comment as the last inner item of an inline object type', () => {
+        const source = `\
+contract Foo: {
+    bar: {
+        a: string
+        # trailing note
+    }
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('# trailing note');
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+
+    it('preserves multiple trailing comments in an inline object type', () => {
+        const source = `\
+contract Foo: {
+    bar: {
+        a: string
+        # note one
+        # note two
+    }
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('# note one');
+        expect(out).toContain('# note two');
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+
+    it('preserves a trailing comment as the only inner item of an inline object type', () => {
+        const source = `\
+contract Foo: {
+    bar: {
+        # placeholder
+    }
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('# placeholder');
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+
+    it('still attaches an inline comment on an inline field (no regression)', () => {
+        const source = `\
+contract Foo: {
+    bar: {
+        a: string # about a
+        b: int
+    }
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('a: string # about a');
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+});
+
+describe('printCk — options block sub-block comments (round-trip)', () => {
+    function roundTrip(source: string): string {
+        const diag = new DiagnosticCollector();
+        const ast = parseCk(source, 'test.ck', diag);
+        expect(diag.hasErrors()).toBe(false);
+        return printCk(ast);
+    }
+
+    it('preserves a leading comment on a keys entry', () => {
+        const source = `\
+options {
+    keys: {
+        # the api area
+        area: payments
+        version: v2
+    }
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('# the api area');
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+
+    it('preserves a trailing comment at the end of the keys sub-block', () => {
+        const source = `\
+options {
+    keys: {
+        area: payments
+        # more keys to come
+    }
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('# more keys to come');
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+
+    it('preserves a leading comment on a services entry', () => {
+        const source = `\
+options {
+    services: {
+        # payments backend
+        PaymentsService: "#src/services/payments.service.js"
+    }
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('# payments backend');
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+
+    it('preserves a comment at the end of the last options sub-block (end of options block)', () => {
+        const source = `\
+options {
+    keys: {
+        area: payments
+    }
+    services: {
+        PaymentsService: "#src/services/payments.service.js"
+        # end of options
+    }
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toContain('# end of options');
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+
+    it('preserves both leading and trailing comments across keys and services', () => {
+        const source = `\
+options {
+    keys: {
+        # area comment
+        area: payments
+        # trailing keys
+    }
+    services: {
+        # service comment
+        PaymentsService: "#src/services/payments.service.js"
+        # trailing services
+    }
+}
+`;
+        const out = roundTrip(source);
+        expect(out).toBe(source);
+        expect(roundTrip(out)).toBe(out);
+    });
+});