@contractkit/prettier-plugin 0.13.0 → 0.14.1

package/.turbo/turbo-build$colon$ci.log

@@ -5,9 +5,9 @@ $ tsup src/index.ts --format esm --sourcemap --dts && tsc --emitDeclarationOnly
 CLI tsup v8.5.1
 CLI Target: esnext
 ESM Build start
-ESM dist/index.js     24.87 KB
-ESM dist/index.js.map 62.23 KB
-ESM ⚡️ Build success in 191ms
+ESM dist/index.js     27.08 KB
+ESM dist/index.js.map 69.36 KB
+ESM ⚡️ Build success in 174ms
 DTS Build start
-DTS ⚡️ Build success in 4964ms
-DTS dist/index.d.ts 1.13 KB
+DTS ⚡️ Build success in 5639ms
+DTS dist/index.d.ts 1.65 KB

package/.turbo/turbo-test$colon$ci.log

@@ -3,24 +3,26 @@ $ vitest run --coverage
  RUN  v4.1.5 /home/runner/work/ContractKit/ContractKit/apps/prettier-plugin
       Coverage enabled with v8
 
- ✓ tests/print-ck.test.ts (81 tests) 676ms
- ✓ tests/round-trip.test.ts (20 tests) 1570ms
-     ✓ formats test.ck to itself  587ms
-     ✓ formatting is a fixed point for source #0  769ms
+ ✓ tests/format-plugin.test.ts (3 tests) 136ms
+ ✓ tests/print-ck.test.ts (81 tests) 1049ms
+ ✓ tests/round-trip.test.ts (49 tests) 2210ms
+     ✓ formats test.ck to itself  918ms
+     ✓ formatting is a fixed point for source #0  515ms
 
- Test Files  2 passed (2)
-      Tests  101 passed (101)
-   Start at  15:07:02
-   Duration  7.40s (transform 3.64s, setup 0ms, import 9.29s, tests 2.25s, environment 0ms)
+ Test Files  3 passed (3)
+      Tests  133 passed (133)
+   Start at  17:32:00
+   Duration  8.78s (transform 4.30s, setup 0ms, import 15.52s, tests 3.40s, environment 1ms)
 
  % Coverage report from v8
 -------------------|---------|----------|---------|---------|-------------------
 File               | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
 -------------------|---------|----------|---------|---------|-------------------
-All files          |   75.62 |    69.04 |   84.21 |   81.34 |                   
+All files          |    79.5 |    74.08 |   93.47 |   86.44 |                   
  indent.ts         |     100 |      100 |     100 |     100 |                   
- print-ck.ts       |   88.34 |       85 |     100 |   97.18 | 80-81             
- print-contract.ts |   45.71 |    38.23 |      50 |   46.66 | 20,52-85          
- ...t-operation.ts |   78.32 |    69.46 |   94.44 |   86.12 | ...37,354,362-373 
- print-type.ts     |   64.13 |    63.46 |   63.63 |   66.66 | ...02-103,148-151 
+ index.ts          |   81.81 |      100 |     100 |      80 | 47-48             
+ print-ck.ts       |   90.59 |    88.26 |     100 |     100 | ...57-158,172,176 
+ print-contract.ts |   74.28 |    60.29 |     100 |      80 | 70-76,83          
+ ...t-operation.ts |   78.77 |    71.42 |      95 |   87.55 | ...63,380,388-399 
+ print-type.ts     |   69.56 |    64.42 |   81.81 |      72 | ...,45-61,148-151 
 -------------------|---------|----------|---------|---------|-------------------

package/CHANGELOG.md

@@ -1,5 +1,67 @@
 # @contractkit/prettier-plugin-contractkit
 
+## 0.14.1
+
+### Patch Changes
+
+- ab69718: Stop the formatter deleting comments in and around a `security { }` block, and keep the trailing newline at end of file.
+
+    The identical bug in `response { }` was fixed in 0.14.0; this position was not covered. `SecurityBody_fields` skipped standalone comments outright, so a `#` run inside a security block never reached the AST and `pnpm format` deleted it with no warning — exactly the prose that records _why_ a policy floor sits where it does. Three more positions failed the same way and now round-trip:
+    - a comment run above a body key in an operation body (the common case being a note above the `security:` key, or above `security: none`, explaining why a verb overrides the file's floor);
+    - a comment run above a verb that also carries its own inline `# ...` doc comment — the inline comment won and the run above it was discarded;
+    - a comment left after the last key in an operation body, before the closing brace.
+
+    `SecurityPolicyLine` and `SecuritySignatureLine` no longer take a trailing `comment?`. Whitespace skipping in an Ohm syntactic rule crosses newlines, so that optional comment swallowed a standalone comment written on the _next_ line and re-emitted it as the policy's inline description — turning a note to the next contract author into generated SDK documentation. `SecurityBody_fields` now collects every comment and decides which one is inline by comparing source lines, the same way `FieldList` already does.
+
+    The same newline-crossing optional appeared on `ModelBody_alias`, where it was worse: it claimed the doc comment of the _next_ declaration. `contract Status: enum(a, b)` followed by a documented contract either lost that doc comment outright, or silently re-filed it as `Status`'s own description — which then flowed into generated SDK docs describing the wrong type. Declaration-level comments are now items in `Root` (`DeclItem`) rather than a `comment*` prefix on each declaration, so their placement is decided where the previous declaration's end line is known: same line as the declaration above → its inline description; directly above the next one → its doc comment; otherwise a standalone block. A comment after the last declaration in a file used to be a parse error and is now kept as `CkRootNode.trailingComments`.
+
+    Two field positions were lost the same way. A comment on a nested object's opening brace (`rp: { # The relying party`) was offered to the first field _inside_ the object and dropped when that field had its own comment; it now belongs to the field owning the brace. A trailing comment on a field whose type wraps over several lines — `enum(\n  a,\n  b\n) # note` — was compared against the line the field _started_ on, so it was filed as a standalone comment for the next field; it now compares against the line the field ends on.
+
+    `SecurityFields` gains `leadingComments` / `trailingComments`, `OpOperationNode` gains `bodyLeadingComments`, `bodyTrailingComments`, and `leadingComments`, and `CkRootNode` gains `trailingComments`. All are optional and additive, so codegen plugins are unaffected.
+
+    ### `#` where it is not a comment
+
+    `nameText` ended a name at any `#`, so `name: Generate C# client` silently became `Generate C` and the rest vanished with no diagnostic. It now ends at whitespace-then-`#`, matching `optionsRawChar` — a bare `#` is data, and only ` #` opens a comment. That makes the two unquoted-text positions in the language consistent with each other. The TextMate `name-decl` pattern captured the whole rest of the line, colouring a trailing comment as part of the name; it now stops at the same boundary the parser does.
+
+    Note that a `name:` containing a bare `#` now parses to its full text, and the SDK method name is derived from `name:` — so a contract that was silently relying on the truncated value will see that method renamed. Only a name with a `#` in it is affected.
+
+    Separately, the prettier plugin trimmed the printed source and returned it without re-adding a terminator, so every formatted `.ck` file lost its trailing newline — fighting any editor or lint rule that wants one. The plugin now has end-to-end tests that go through prettier itself rather than calling `printCk` directly, which is the layer where that slipped through.
+
+- Updated dependencies [ab69718]
+    - @contractkit/core@0.26.0
+
+## 0.14.0
+
+### Minor Changes
+
+- 85d7566: Let an operation emit more than one status, and a status serve more than one content type.
+
+    A status code could previously declare only one mime — the parser warned `Duplicate response body` and dropped the rest — and the generated router pinned both `ctx.status` and `ctx.type` to whichever response happened to be listed first with a body. An endpoint serving several formats had to declare one lying mime and let browsers sniff, and a service had no way to say which status it produced.
+
+    A status now holds every declared `mime: Type` line (`OpResponseNode.bodies`). When there is more than one, the service picks at runtime and the router sets `ctx.type` from the returned `contentType`. When an operation produces more than one status, the service returns a union discriminated on `status` and the handler switches on it, so each status writes only its own headers, mime and body. Both SDKs mirror the router: the TypeScript and Python clients return a matching union, report which mime came back, and pass the non-2xx statuses they expect to the shared fetch so a declared `304` no longer surfaces as an error. `SdkError` now takes a body type parameter, and each operation exports a `…ErrorBody` alias for the statuses that stay on the throw path.
+
+    Which statuses the service produces is derived from the declaration: **a status is emitted if it has a block, or is 2xx.** An empty block (`304: {}`) says the service returns that status carrying nothing; a bare `304:` says it is documented and something else produces it. `404(documented): { … }` is the one modifier, forcing a block-carrying status back out.
+
+    Two long-standing bugs in the same area go with it. The formatter deleted any comment written inside a `response` block — above a status code, above a mime line, above a `headers:` block, or before a closing brace — so `pnpm format` silently threw away the notes explaining why a contract looks the way it does; all four positions now round-trip. And the generated router declared a `_ZodBinary` helper for a binary _response_ body, which is a plain `Buffer` annotation with no schema behind it, leaving an unused const that tripped `noUnusedLocals` downstream; helpers are now chosen from the code that was actually generated, the same way imports already were.
+
+    **If you are already on a pre-release version, two things change under you.** A contract that declares a body on an error status — `404: { application/json: Problem }` alongside a `200` — now returns it from the service instead of throwing, and the SDK return type becomes a union; add `(documented)` to that status to keep the previous behaviour. Contracts whose error statuses are bodyless (`400:`, `404:`) are unaffected. Anything reading the AST directly should move from `OpResponseNode.contentType`/`bodyType` to `bodies`, which replaces them.
+
+- 90d19ee: Allow a comment above `options`, and a trailing comment on an options entry.
+
+    A `#` comment above a `contract` or `operation` has always been fine, but one above the `options` keyword was a parse error — a file header is a natural thing to write, and writing it broke the build. `OptionsBlock` now owns the leading `comment*`. It lives there rather than on `Root` deliberately: on `Root` its greedy match would swallow the doc comment above a `contract` in a file that has no options block at all.
+
+    A trailing comment on a `keys`/`services` entry was worse than unsupported: it was swallowed into the value, and because an unquoted value ends at the first `}`, a comment containing one — `# interpolated as {{area}}` — closed the block early and silently mis-parsed the rest of the file. The value now ends at whitespace-then-`#`, and the comment is retained so the formatter round-trips it. A `#` with no space before it still belongs to the value, so the unquoted subpath form (`PetService: #modules/pet/pet.service.js`) is unaffected.
+
+    The TextMate grammar had the matching gap: its unquoted-value pattern accepted identifiers only, so an unquoted subpath fell through to the comment pattern and was coloured as though the parser ignored it.
+
+    An unquoted value also stays unquoted. The AST now records which entries were authored bare, so the formatter reproduces that choice instead of normalizing every value to the quoted form. The flag is formatting-only — both forms parse to the same string — and a value that could not be read back bare is still quoted, which covers values built programmatically rather than parsed.
+
+### Patch Changes
+
+- Updated dependencies [85d7566]
+- Updated dependencies [90d19ee]
+    - @contractkit/core@0.25.0
+
 ## 0.13.0
 
 ### Minor Changes

package/README.md

@@ -51,7 +51,15 @@ Formatting a well-formed `.ck` file leaves it byte-identical. The formatter deli
 - **Comment placement.** A `#` block separated from the declaration below it by a blank line stays a standalone divider; one directly above becomes that declaration's doc comment and is re-emitted above it, not folded onto the header line. A comment written inline (`contract Pet: { # ...`) stays inline.
 - **Operation body key order.** `sdk` before `service` stays that way; the printer never sorts a user's keys into a canonical order.
 - **Blank lines** between operations inside a route.
-- **Single-line response blocks.** `200: { application/json: Pet }` is not expanded, and an expanded block is not collapsed.
+- **Single-line response blocks.** `200: { application/json: Pet }` is not expanded, and an expanded block is not collapsed. A status declaring several mimes on one line stays on one line too.
+- **Comments inside a `response` block**, in all four positions: above a status code, above a `mime: Type` line, above a `headers:` block, and before either closing brace.
+- **An empty status block.** `304: {}` and `304:` mean different things to codegen — the first says the service returns that status with no body — so neither is normalized into the other.
+- **Comments in the `options` block**, including a header comment above the `options` keyword and a trailing comment on a `keys`/`services` entry.
+- **Comments in and around a `security { }` block**: inside it above or below `policy:`, above a `security:` key on a verb, and above a `security: none` line. This is where the rationale for a policy floor is written, so losing it loses the reason the contract looks the way it does.
+- **Comments above any operation body key**, and after the last one. A `#` block above a verb survives even when the verb carries its own inline `# ...` — they are separate, and only the inline one is the description.
+- **Comments between declarations.** A comment trailing a one-line contract stays on that line; one directly above the next declaration stays its doc comment. A comment after the last declaration in the file is kept too.
+- **Comments on a nested object's brace** (`rp: { # ... }`) and trailing a field whose type wraps over several lines.
+- **Unquoted options values.** `PetService: #modules/pet/pet.service.js` stays bare and a quoted value stays quoted. Both parse to the same string, so the parser records which form was written; a value that could not be read back bare is quoted regardless.
 
 This is covered by `tests/round-trip.test.ts`, which formats every `.ck` file under `contracts/` and asserts the output is unchanged, plus checks that formatting is a fixed point. Anything that makes the printer normalize rather than preserve will fail it.
 

package/dist/index.d.ts

@@ -1,5 +1,13 @@
 import type { Plugin } from 'prettier';
 import type { CkRootNode } from '@contractkit/core';
+/**
+ * Prettier plugin registering the `.ck` language, its parser, and its printer.
+ *
+ * The parser is `parseCk` and the printer is `printCk`, so formatting behaviour lives in
+ * `@contractkit/core` and `print-ck.ts` rather than here — this module only adapts them to
+ * prettier's interface. `tests/format-plugin.test.ts` covers that adapter layer, which a
+ * printer-level test cannot reach.
+ */
 declare const plugin: Plugin<CkRootNode>;
 export default plugin;
 export { printCk, DEFAULT_PRINT_WIDTH } from './print-ck.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAUpD,QAAA,MAAM,MAAM,EAAE,MAAM,CAAC,UAAU,CA8B9B,CAAC;AAEF,eAAe,MAAM,CAAC;AACtB,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAkBpD;;;;;;;GAOG;AACH,QAAA,MAAM,MAAM,EAAE,MAAM,CAAC,UAAU,CA8B9B,CAAC;AAEF,eAAe,MAAM,CAAC;AACtB,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -348,7 +348,7 @@ function printOperationKey(op, key) {
       return lines;
     }
     case "responses":
-      return op.responses.length > 0 ? printResponseBlock(op.responses) : [];
+      return op.responses.length > 0 ? printResponseBlock(op.responses, op.responsesTrailingComments) : [];
   }
 }
 __name(printOperationKey, "printOperationKey");
@@ -356,6 +356,7 @@ function printOperation(op) {
   const lines = [];
   const modPart = op.modifiers?.length ? `(${op.modifiers[0]})` : "";
   const inlineDescription = op.descriptionInline ?? true;
+  for (const c of op.leadingComments ?? []) lines.push(`${I1}# ${c}`);
   if (op.description && !inlineDescription) {
     for (const line of op.description.split("\n")) lines.push(`${I1}# ${line}`);
   }
@@ -363,12 +364,24 @@ function printOperation(op) {
   lines.push(`${I1}${op.method}${modPart}: {${commentSuffix}`);
   const order = op.keyOrder ?? [];
   const rest = CANONICAL_KEY_ORDER.filter((k) => !order.includes(k));
+  const orphaned = [];
   for (const key of [
     ...order,
     ...rest
   ]) {
-    lines.push(...printOperationKey(op, key));
+    const keyLines = printOperationKey(op, key);
+    const comments = op.bodyLeadingComments?.[key] ?? [];
+    if (keyLines.length === 0) {
+      orphaned.push(...comments);
+      continue;
+    }
+    for (const c of comments) lines.push(`${I2}# ${c}`);
+    lines.push(...keyLines);
   }
+  for (const c of [
+    ...orphaned,
+    ...op.bodyTrailingComments ?? []
+  ]) lines.push(`${I2}# ${c}`);
   lines.push(`${I1}}`);
   return lines;
 }
@@ -470,13 +483,19 @@ function printSecurity(security, indent = I2, innerIndent = I3) {
     `${indent}security: none`
   ];
   const fields = security;
-  if (fields.policy === void 0) return [];
+  const leading = fields.leadingComments ?? [];
+  const trailing = fields.trailingComments ?? [];
+  if (fields.policy === void 0 && leading.length === 0 && trailing.length === 0) return [];
   const lines = [
     `${indent}security: {`
   ];
-  const comment = fields.policyDescription ? ` # ${fields.policyDescription}` : "";
-  const value = fields.policy === false ? "none" : fields.policy;
-  lines.push(`${innerIndent}policy: ${value}${comment}`);
+  for (const c of leading) lines.push(`${innerIndent}# ${c}`);
+  if (fields.policy !== void 0) {
+    const comment = fields.policyDescription ? ` # ${fields.policyDescription}` : "";
+    const value = fields.policy === false ? "none" : fields.policy;
+    lines.push(`${innerIndent}policy: ${value}${comment}`);
+  }
+  for (const c of trailing) lines.push(`${innerIndent}# ${c}`);
   lines.push(`${indent}}`);
   return lines;
 }
@@ -531,21 +550,29 @@ function printContentTypeLine(contentType, bodyType, lineIndent) {
   ];
 }
 __name(printContentTypeLine, "printContentTypeLine");
-function printResponseBlock(responses) {
+function printResponseBlock(responses, trailingComments) {
   const lines = [
     `${I2}response: {`
   ];
   for (const resp of responses) {
-    const hasBody = resp.contentType && resp.bodyType;
+    for (const comment of resp.leadingComments ?? []) lines.push(`${I3}# ${comment}`);
+    const bodies = resp.bodies;
     const hasHeaders = resp.headers && resp.headers.length > 0;
     const optOut = resp.headersOptOut;
-    if (resp.inline && hasBody && !hasHeaders && !optOut && resp.bodyType.kind !== "inlineObject") {
-      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));
+    const code = resp.emit ? `${resp.statusCode}(${resp.emit})` : `${resp.statusCode}`;
+    const inlinable = resp.inline && bodies.length > 0 && !hasHeaders && !optOut && bodies.every((b) => b.bodyType.kind !== "inlineObject");
+    if (inlinable) {
+      const inner = bodies.map((b) => `${b.contentType}: ${printType(b.bodyType)}`).join(" ");
+      lines.push(`${I3}${code}: { ${inner} }`);
+    } else if (bodies.length === 0 && !hasHeaders && !optOut && resp.hasBlock) {
+      lines.push(`${I3}${code}: {}`);
+    } else if (bodies.length > 0 || hasHeaders || optOut || (resp.trailingComments?.length ?? 0) > 0) {
+      lines.push(`${I3}${code}: {`);
+      for (const body of bodies) {
+        for (const comment of body.leadingComments ?? []) lines.push(`${I4}# ${comment}`);
+        lines.push(...printContentTypeLine(body.contentType, body.bodyType, I4));
       }
+      for (const comment of resp.headersLeadingComments ?? []) lines.push(`${I4}# ${comment}`);
       if (optOut) {
         lines.push(`${I4}headers: none`);
       } else if (hasHeaders) {
@@ -557,11 +584,13 @@ function printResponseBlock(responses) {
         }
         lines.push(`${I4}}`);
       }
+      for (const comment of resp.trailingComments ?? []) lines.push(`${I4}# ${comment}`);
       lines.push(`${I3}}`);
     } else {
-      lines.push(`${I3}${resp.statusCode}:`);
+      lines.push(`${I3}${code}:`);
     }
   }
+  for (const comment of trailingComments ?? []) lines.push(`${I3}# ${comment}`);
   lines.push(`${I2}}`);
   return lines;
 }
@@ -569,15 +598,19 @@ __name(printResponseBlock, "printResponseBlock");
 
 // src/print-ck.ts
 var DEFAULT_PRINT_WIDTH = 80;
-function quoteOptionsValue(value) {
-  return /^[a-zA-Z_$][a-zA-Z0-9_$\-.]*$/.test(value) ? value : `"${value}"`;
+function quoteOptionsValue(value, wasUnquoted = false) {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$\-.]*$/.test(value)) return value;
+  const roundTripsBare = value.length > 0 && value === value.trim() && !/[\n\r}]/.test(value) && !/[ \t]#/.test(value) && !/^["']/.test(value);
+  return wasUnquoted && roundTripsBare ? value : `"${value}"`;
 }
 __name(quoteOptionsValue, "quoteOptionsValue");
-function emitOptionsEntries(lines, entries, comments) {
+function emitOptionsEntries(lines, entries, comments, unquoted) {
   const I22 = INDENT + INDENT;
+  const wasUnquoted = new Set(unquoted ?? []);
   for (const [key, value] of Object.entries(entries)) {
     for (const c of comments?.leading?.[key] ?? []) lines.push(`${I22}# ${c}`);
-    lines.push(`${I22}${key}: ${quoteOptionsValue(value)}`);
+    const inline = comments?.inline?.[key];
+    lines.push(`${I22}${key}: ${quoteOptionsValue(value, wasUnquoted.has(key))}${inline !== void 0 ? ` # ${inline}` : ""}`);
   }
   for (const c of comments?.trailing ?? []) lines.push(`${I22}# ${c}`);
 }
@@ -591,6 +624,7 @@ function printOptionsBlock(ast) {
   const hasBodyComments = ast.optionsComments?.body !== void 0;
   if (!hasMeta && !hasServices && !hasSecurity && !hasRequestHeaders && !hasResponseHeaders && !hasBodyComments) return null;
   const lines = [
+    ...(ast.optionsComments?.leading ?? []).map((c) => `# ${c}`),
     "options {"
   ];
   const body = ast.optionsComments?.body;
@@ -600,13 +634,13 @@ function printOptionsBlock(ast) {
   if (hasMeta) {
     emitLeading("keys");
     lines.push(`${INDENT}keys: {`);
-    emitOptionsEntries(lines, ast.meta, ast.optionsComments?.keys);
+    emitOptionsEntries(lines, ast.meta, ast.optionsComments?.keys, ast.optionsUnquoted?.keys);
     lines.push(`${INDENT}}`);
   }
   if (hasServices) {
     emitLeading("services");
     lines.push(`${INDENT}services: {`);
-    emitOptionsEntries(lines, ast.services, ast.optionsComments?.services);
+    emitOptionsEntries(lines, ast.services, ast.optionsComments?.services, ast.optionsUnquoted?.services);
     lines.push(`${INDENT}}`);
   }
   if (hasRequestHeaders) {
@@ -660,6 +694,10 @@ function printCk(ast, printWidth = DEFAULT_PRINT_WIDTH) {
     const modPart = route.modifiers?.length ? `(${route.modifiers[0]})` : "";
     parts.push(printDeclLeadIn(route.leadingComments, route.description) + `operation${modPart} ${printRoute(route, emptyBlocks, emptyIdx, Infinity)}`);
   }
+  if (ast.trailingComments?.length) {
+    if (parts.length > 0) parts.push("");
+    for (const c of ast.trailingComments) parts.push(`# ${c}`);
+  }
   return parts.join("\n") + "\n";
 }
 __name(printCk, "printCk");
@@ -680,7 +718,10 @@ __name(printDeclLeadIn, "printDeclLeadIn");
 var { hardline, join } = builders;
 function toDoc(text) {
   const lines = text.trimEnd().split("\n");
-  return join(hardline, lines);
+  return [
+    join(hardline, lines),
+    hardline
+  ];
 }
 __name(toDoc, "toDoc");
 var plugin = {