@zgeoff/format-codemod 0.0.4 → 0.0.6

package/README.md

@@ -1,106 +1,119 @@
 # @zgeoff/format-codemod
 
-Enforce a small set of blank-line padding conventions in TypeScript via a fast text-splice codemod.
-It parses each file once with [oxc-parser](https://oxc.rs) (native, so parsing is effectively free),
-plans positional whitespace splices from node and comment spans, and skips type-aware analysis, so
-it runs far faster than a full lint pass — fast enough to sit in a pre-commit hook or a `format`
-pipeline without being noticed.
+Machine-owned vertical spacing for TypeScript. Every gap between adjacent statements is normalized
+to exactly one blank line where a rule below requires one, and zero where none does — a superset of
+ESLint's `padding-line-between-statements` and `@stylistic/lines-between-class-members`, run as a
+text-splice codemod. Each file is parsed once with [oxc-parser](https://oxc.rs) (native) and edited
+by positional whitespace splices — no type-aware analysis — so a pass is fast enough for a
+pre-commit hook or a `format` pipeline. Runs are idempotent: a pass over compliant code is a no-op.
 
-## Rules implemented
+Three kinds of gap are left alone:
 
-Mirrors a subset of ESLint's `padding-line-between-statements` plus
-`@stylistic/lines-between-class-members`. Every rule is "always exactly one blank line"; there are
-no "never" rules.
+- A gap holding any comment is never collapsed, only grown — prose between statements marks
+  intentional grouping the rules can't see.
+- The interior of an import block is never touched — it belongs to the import sorter. The boundary
+  after the last import is still padded.
+- Two statements sharing a physical line (a leading-semicolon `;(expr)` guard) are skipped — a
+  blank-only edit can't separate them without orphaning a token.
 
-**`padding-line-between-statements`** — insert one blank line:
+## Rules
 
-- after a `const`/`let`/`var` block, before any non-var statement
-- before any `return`
+**Padded on both sides** — the statement is its own paragraph:
+
+- a control-flow block: `if`, `for`, `for…in`, `for…of`, `while`, `switch`, `try`
+- any statement that spans multiple lines
+- a type alias or interface declaration — runs of them are padded apart, not glued. This is the one
+  rule that looks through `export`: `export type X = …` pads like `type X = …`.
+
+**Padded on one side:**
+
+- before every `return`
 - after a `function` or `class` declaration
-- on both sides of a control-flow block: `if`, `for`, `for…in`, `for…of`, `while`, `switch`, `try`
-- on both sides of any statement that spans multiple lines
-- at the boundary between statement kinds — a `const`/`let`/`var` declaration, a
-  `using`/`await using` declaration, a call statement, an assignment/increment statement — in any
-  order; runs of one kind stay tight
-- after a `using`/`await using` block, before any statement of another kind
-- at the boundary between an instantiation-headed statement (`new` at the head of its expression
-  chain, as in `new X(…)` or `new X(…).method()`) and any other statement kind — `new` in argument
-  position doesn't count, and runs of instantiations stay glued
-- at the boundary between an awaited and a non-awaited statement — awaited means an `await using`
-  declaration, or an `await` in the head of the statement's value chain (`await f()`,
-  `const x = await f()`, `x = (await f()).prop`); an `await` in argument position (`use(await f())`)
-  or under a non-chain head (`flag ? await f() : g()`) doesn't count, and runs of awaited statements
-  stay glued
-
-**`@stylistic/lines-between-class-members`** — one blank line between class members.
-
-### Notes
-
-- **Consecutive single-line `const`/`let`/`var` declarations stay glued** (no blank between them); a
-  multiline declaration is separated like any other multiline statement.
-- **Bare declarations only.** `export const`, `export function`, and `export class` are not matched
-  — ESLint's selectors do not look through `export`, and neither does this. `using`/`await using`
-  declarations are not var declarations; they form their own statement kind.
-- **The `using` and awaited-boundary rules go beyond ESLint** — `padding-line-between-statements`
-  cannot express either, so on these the codemod is the spec.
-- **`.d.ts` files are skipped.**
+- after a directive prologue (`'use strict'`, `'use client'`); runs of directives stay glued
+- after the last import of a block
+
+**Kind boundaries** — statements classify into kinds; a run of one kind sits flush, and the boundary
+between two kinds takes a blank line:
+
+- `const`/`let`/`var` declarations
+- `using`/`await using` declarations
+- bare calls and method calls — two distinct kinds, split by the first call in reading order:
+  `expect(x).toBe(y)` opens with a bare function, `fs.writeFileSync(…)` opens with a member, and a
+  member call chained onto a bare call's result is still a bare call
+- assignments and increments
+
+Two axes overlay the kinds and pad their own boundaries:
+
+- instantiation — a statement headed by `new` (`new X(…)`, `new X(…).method()`) is separated from
+  any non-instantiation statement; `new` in argument position doesn't count, and runs of
+  instantiations stay glued
+- awaitedness — an awaited statement (`await using`, or an `await` in the head of the statement's
+  value chain: `await f()`, `const x = await f()`) is separated from non-awaited ones; an `await` in
+  argument position (`use(await f())`) or under a non-chain head (`flag ? await f() : g()`) doesn't
+  count, and runs of awaited statements stay glued
+
+**Class members** — one blank line between members.
+
+Only bare declarations match the declaration rules: `export const`, `export function`, and
+`export class` are not declarations to the classifier (type aliases and interfaces are the one
+exception, above).
+
+Comment positions come from the parser, not lexical scanning, so comment-lookalike text can't
+mislead the classification. A trailing same-line comment stays attached to the statement before it —
+the blank line goes after the comment; a comment on its own line attaches to the statement after it
+— the blank line goes before. The next statement's indentation is preserved.
 
 ## CLI
 
 ```bash
 format-codemod [options] <file|dir|glob> ...
 
-  --check     exit 1 if any file would change; do not write
-  --dry       print unified diff to stdout; do not write
-  --bench     print parse stats as JSON to stderr
-  --quiet     only print files that would change
+  --check            exit 1 if any file would change; do not write
+  --dry              print unified diff to stdout; do not write
+  --bench            print parse stats as JSON to stderr
+  --quiet            only print files that would change
+  --ignore <glob>    skip files matching the glob (repeatable)
   --version
   --help
 ```
 
-Flags are strict: an unknown flag is a usage error (exit 2), never a silent no-op — the default mode
-writes files, so a typo'd `--check` must not fall through to a rewrite.
-
-### Examples
+Flags are strict: an unknown flag is a usage error, never a silent no-op — the default mode writes
+files, so a typo'd `--check` must not fall through to a rewrite. Exit codes: `0` clean, `1` files
+would change (`--check`), `2` usage error or one or more files failed (parse error, unreadable,
+unwritable).
 
 ```bash
 format-codemod 'src/**/*.{ts,tsx}'           # rewrite in place
 format-codemod --check 'src/**/*.{ts,tsx}'   # CI gate
-format-codemod --dry path/to/file.ts         # preview diff
+format-codemod --dry path/to/file.ts         # preview diff; applies cleanly with patch(1)
 format-codemod .                             # whole repo, in place
 ```
 
-Globs use Node 22's built-in `fs.glob`. A literal path is resolved as a file before the glob
-heuristic runs, so bracketed names (Next.js routes like `[slug]/page.tsx`) are handled correctly
-rather than read as glob character classes. A directory argument expands to `**/*.{ts,tsx}` beneath
-it; `node_modules` and `.git` are never descended into, and overlapping patterns are deduped so a
-file is processed once.
-
-`--dry` prints a real unified diff — `@@` hunk headers with three lines of context — that applies
-cleanly with `patch(1)`.
+### Inputs
 
-## Dialect handling
+Globs use Node's built-in `fs.glob`. A literal path is resolved as a file before the glob heuristic
+runs, so bracketed names (Next.js routes like `[slug]/page.tsx`) are read as files, not glob
+character classes. A directory expands to `**/*.{ts,tsx}` beneath it; `node_modules` and `.git` are
+never descended into, and overlapping patterns are deduped so each file is processed once. `.d.ts`
+files are skipped. The extension picks the parse dialect: `.tsx` enables JSX, everything else parses
+as plain TypeScript — so `.ts`-only syntax (`<string>value` assertions, un-comma'd generic arrows
+`<T>(a: T) => a`) parses correctly instead of being misread as JSX.
 
-The filename picks the parse dialect: `.tsx` enables JSX, everything else parses as plain
-TypeScript. That means `.ts`-only syntax — old-style type assertions (`<string>value`), un-comma'd
-generic arrows (`<T>(a: T) => a`) — parses correctly instead of being misread as JSX.
+### Ignoring files
 
-## Trivia handling
+A `.formatignore` file in the working directory supplies ignore globs — one per line, blank lines
+and `#`-prefixed comment lines skipped:
 
-Comment positions come from the parser, not lexical scanning:
-
-- Trailing same-line comments stay attached to the previous statement: `const X = 1; // note` keeps
-  the blank line _after_ the comment (several same-line comments all stay together).
-- Leading comments stay attached to the next statement: the blank line goes _before_ the comment.
-- Indentation of the next statement is preserved.
-- Two statements that share a physical line are left untouched — for example a leading-semicolon
-  `;(expr)` whose `;` terminates the previous statement. A blank-only edit cannot separate them
-  without orphaning a token, so the codemod skips the pair.
-
-## Idempotent
+```gitignore
+# committed codegen
+src/generated/**
+dist/**
+```
 
-Running the codemod twice produces the same output as running it once. A run on already-compliant
-code is a no-op.
+Each line uses the same semantics as `--ignore` (Node's `path.matchesGlob`, tried against both the
+expanded path and the path relative to the working directory). It is not a gitignore dialect: `!`
+negation and directory-anchoring rules are not supported. `--ignore` flags merge additively with the
+file's globs.
 
 ## Programmatic use
 
@@ -112,5 +125,5 @@ const { output, edits, parseError } = transform(source, { filename: 'component.t
 // parseError: error message if the source could not be parsed; source returned untouched
 ```
 
-`filename` is optional and only drives dialect selection (default `'source.ts'` — plain TypeScript,
-no JSX); nothing is read from disk.
+`filename` is optional and only picks the dialect (default `'source.ts'` — plain TypeScript, no
+JSX); nothing is read from disk.

package/dist/cli/load-format-ignore.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reads `.formatignore` from the given directory: one glob per line, blank
+ * lines and `#`-prefixed comment lines skipped. Lines share --ignore's glob
+ * semantics — this is not a gitignore dialect, so `!` negation and directory
+ * anchoring don't apply. A missing file yields an empty list, so callers
+ * merge unconditionally.
+ */
+export declare function loadFormatIgnore(dir: string): readonly string[];

package/dist/cli.js

@@ -49,6 +49,18 @@ function isIgnored(file, patterns) {
   return patterns.some((pattern) => path.matchesGlob(file, pattern) || path.matchesGlob(relative, pattern));
 }
 
+// src/cli/load-format-ignore.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+function loadFormatIgnore(dir) {
+  const file = path2.join(dir, ".formatignore");
+  if (!fs2.existsSync(file)) {
+    return [];
+  }
+  return fs2.readFileSync(file, "utf8").split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+
 // src/cli/parse-cli-args.ts
 import { parseArgs } from "node:util";
 function parseCLIArgs(argv) {
@@ -103,6 +115,11 @@ options:
   --version
   --help
 
+files:
+  .formatignore      read from the working directory when present: one glob per
+                     line, blank lines and # comments skipped, merged with
+                     --ignore
+
 exit codes:
   0  clean
   1  files would change (--check)
@@ -133,9 +150,9 @@ function printReport(file, report, quiet) {
 }
 
 // src/cli/read-package-version.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 function readPackageVersion(pkgPath) {
-  const parsed = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+  const parsed = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
   if (!isPackageJSON(parsed)) {
     throw new TypeError("Invalid package.json");
   }
@@ -146,7 +163,7 @@ function isPackageJSON(value) {
 }
 
 // src/cli/check-file.ts
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 
 // src/transform/apply-edits.ts
 function applyEdits(src, edits) {
@@ -190,6 +207,27 @@ function collectChildNodes(node) {
   return children;
 }
 
+// src/transform/collect-head-chain.ts
+var HEAD_PROPERTY = {
+  CallExpression: "callee",
+  MemberExpression: "object",
+  ChainExpression: "expression",
+  AwaitExpression: "argument",
+  TSNonNullExpression: "expression",
+  ParenthesizedExpression: "expression"
+};
+function collectHeadChain(expression) {
+  const chain = [];
+  let current = expression;
+  while (current !== undefined) {
+    chain.push(current);
+    const property = HEAD_PROPERTY[current.type];
+    const inner = property === undefined ? undefined : current[property];
+    current = isASTNode(inner) ? inner : undefined;
+  }
+  return chain;
+}
+
 // src/transform/needs-blank-line.ts
 var CONTROL_FLOW_TYPES = new Set([
   "IfStatement",
@@ -204,19 +242,30 @@ function needsBlankLine(container, prev, next) {
   if (container.type === "ClassBody") {
     return true;
   }
-  if (isVarDecl(prev) && !isVarDecl(next) || isUsingDecl(prev) && !isUsingDecl(next)) {
+  if (isRunEnd(prev, next) || next.type === "ReturnStatement" || isFnOrClassDecl(prev)) {
     return true;
   }
-  if (next.type === "ReturnStatement") {
+  if (isTypeDecl(prev) || isTypeDecl(next)) {
     return true;
   }
-  if (isFnOrClassDecl(prev)) {
+  return isNewHeaded(prev) !== isNewHeaded(next) || isAwaitHeaded(prev) !== isAwaitHeaded(next) || isKindBoundary(prev, next) || CONTROL_FLOW_TYPES.has(next.type) || CONTROL_FLOW_TYPES.has(prev.type);
+}
+function isRunEnd(prev, next) {
+  return isVarDecl(prev) && !isVarDecl(next) || isUsingDecl(prev) && !isUsingDecl(next) || isDirective(prev) && !isDirective(next) || prev.type === "ImportDeclaration" && next.type !== "ImportDeclaration";
+}
+function isDirective(node) {
+  return typeof node["directive"] === "string";
+}
+var TYPE_DECL_TYPES = new Set(["TSTypeAliasDeclaration", "TSInterfaceDeclaration"]);
+function isTypeDecl(node) {
+  if (TYPE_DECL_TYPES.has(node.type)) {
     return true;
   }
-  return isNewHeaded(prev) !== isNewHeaded(next) || isAwaitHeaded(prev) !== isAwaitHeaded(next) || isKindBoundary(prev, next) || CONTROL_FLOW_TYPES.has(next.type) || CONTROL_FLOW_TYPES.has(prev.type);
+  const declaration = node.declaration;
+  return node.type === "ExportNamedDeclaration" && isASTNode(declaration) && TYPE_DECL_TYPES.has(declaration.type);
 }
 function isNewHeaded(node) {
-  return getStatementValues(node).some((value) => getExpressionHead(value).type === "NewExpression");
+  return getStatementValues(node).some((value) => collectHeadChain(value).at(-1)?.type === "NewExpression");
 }
 function getStatementValues(node) {
   if (node.type === "VariableDeclaration") {
@@ -232,44 +281,11 @@ function getStatementValues(node) {
   }
   return [expression];
 }
-var HEAD_PROPERTY = {
-  CallExpression: "callee",
-  MemberExpression: "object",
-  ChainExpression: "expression",
-  AwaitExpression: "argument",
-  TSNonNullExpression: "expression",
-  ParenthesizedExpression: "expression"
-};
-function getExpressionHead(node) {
-  let current = node;
-  let property = HEAD_PROPERTY[current.type];
-  while (property !== undefined) {
-    const inner = current[property];
-    if (!isASTNode(inner)) {
-      break;
-    }
-    current = inner;
-    property = HEAD_PROPERTY[current.type];
-  }
-  return current;
-}
 function isAwaitHeaded(node) {
   if (node.type === "VariableDeclaration" && node.kind === "await using") {
     return true;
   }
-  return getStatementValues(node).some((value) => hasAwaitInHeadChain(value));
-}
-function hasAwaitInHeadChain(node) {
-  let current = node;
-  while (current !== undefined) {
-    if (current.type === "AwaitExpression") {
-      return true;
-    }
-    const property = HEAD_PROPERTY[current.type];
-    const inner = property === undefined ? undefined : current[property];
-    current = isASTNode(inner) ? inner : undefined;
-  }
-  return false;
+  return getStatementValues(node).some((value) => collectHeadChain(value).some((link) => link.type === "AwaitExpression"));
 }
 var CALL_TYPES = ["CallExpression", "AwaitExpression"];
 var MUTATION_TYPES = ["AssignmentExpression", "UpdateExpression"];
@@ -286,10 +302,20 @@ function getStatementKind(node) {
     return "declaration";
   }
   if (isExpressionStatementOf(node, CALL_TYPES)) {
-    return "call";
+    return pickCallKind(node);
   }
   return isExpressionStatementOf(node, MUTATION_TYPES) ? "mutation" : null;
 }
+function pickCallKind(node) {
+  const expression = node["expression"];
+  const callee = isASTNode(expression) ? findDeepestCallee(expression) : null;
+  return callee?.type === "MemberExpression" ? "method-call" : "bare-call";
+}
+function findDeepestCallee(expression) {
+  const deepestCall = collectHeadChain(expression).findLast((link) => link.type === "CallExpression");
+  const callee = deepestCall?.["callee"];
+  return isASTNode(callee) ? callee : null;
+}
 function isExpressionStatementOf(node, types) {
   const expression = node["expression"];
   return node.type === "ExpressionStatement" && isASTNode(expression) && types.includes(expression.type);
@@ -313,12 +339,12 @@ function isFnOrClassDecl(node) {
 }
 
 // src/transform/plan-gap-edit.ts
-function planGapEdit(file, prev, next) {
-  const gap = buildGap(file, prev, next);
+function planGapEdit(input) {
+  const gap = buildGap(input.file, input.prev, input.next);
   if (!isSafeToResize(gap)) {
     return null;
   }
-  return planBlankLineEdit(gap);
+  return input.pad ? planBlankLineEdit(gap) : planCollapseEdit(gap);
 }
 function buildGap(file, prev, next) {
   const start = getNodeEnd(prev);
@@ -400,6 +426,19 @@ function planWhitespaceGap(gap, gapStart, gapEnd) {
 function countNewlines(s) {
   return (s.match(/\n/gu) ?? []).length;
 }
+function planCollapseEdit(gap) {
+  if (gap.comments.length > 0) {
+    return null;
+  }
+  const text = gap.src.slice(gap.start, gap.end);
+  if (countNewlines(text) < MIN_NEWLINES) {
+    return null;
+  }
+  const indent = text.slice(text.lastIndexOf(`
+`) + 1);
+  return { start: gap.start, end: gap.end, replacement: `
+${indent}` };
+}
 
 // src/transform/build-edits-from-ast.ts
 function buildEditsFromAST(src, parsed) {
@@ -432,8 +471,9 @@ function buildPairEdits(file, container, body) {
   for (let i = 0;i < body.length - 1; i++) {
     const prev = body[i];
     const next = body[i + 1];
-    if (prev !== undefined && next !== undefined && !isImportPair(prev, next) && (needsBlankLine(container, prev, next) || isMultiline(file.src, prev) || isMultiline(file.src, next))) {
-      const edit = planGapEdit(file, prev, next);
+    if (prev !== undefined && next !== undefined && !isImportPair(prev, next)) {
+      const pad = needsBlankLine(container, prev, next) || isMultiline(file.src, prev) || isMultiline(file.src, next);
+      const edit = planGapEdit({ file, prev, next, pad });
       if (edit !== null) {
         edits.push(edit);
       }
@@ -478,7 +518,7 @@ function transform(src, options) {
 }
 
 // src/cli/apply-diff-mode.ts
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 
 // src/cli/build-unified-diff.ts
 function buildUnifiedDiff(before, after, label) {
@@ -642,13 +682,13 @@ function applyDiffMode(edit, mode) {
   if (mode === "dry") {
     return { message: null, stdout: buildUnifiedDiff(edit.src, edit.result.output, edit.file) };
   }
-  fs3.writeFileSync(edit.file, edit.result.output);
+  fs4.writeFileSync(edit.file, edit.result.output);
   return { message: `WROTE ${edit.file}  ${edit.result.edits} edit(s)`, stdout: null };
 }
 
 // src/cli/check-file.ts
 function checkFile(file, mode) {
-  const src = fs4.readFileSync(file, "utf8");
+  const src = fs5.readFileSync(file, "utf8");
   const bytes = Buffer.byteLength(src);
   const result = transform(src, { filename: file });
   if (result.parseError !== null) {
@@ -701,7 +741,8 @@ if (parsedArgs.version) {
   process.exit(0);
 }
 var t0 = Date.now();
-var files = await expandInputs(inputs, parsedArgs.ignore);
+var ignore = [...loadFormatIgnore(process.cwd()), ...parsedArgs.ignore];
+var files = await expandInputs(inputs, ignore);
 if (files.length === 0) {
   console.error("no files matched");
   process.exit(2);

package/dist/index.js

@@ -40,6 +40,27 @@ function collectChildNodes(node) {
   return children;
 }
 
+// src/transform/collect-head-chain.ts
+var HEAD_PROPERTY = {
+  CallExpression: "callee",
+  MemberExpression: "object",
+  ChainExpression: "expression",
+  AwaitExpression: "argument",
+  TSNonNullExpression: "expression",
+  ParenthesizedExpression: "expression"
+};
+function collectHeadChain(expression) {
+  const chain = [];
+  let current = expression;
+  while (current !== undefined) {
+    chain.push(current);
+    const property = HEAD_PROPERTY[current.type];
+    const inner = property === undefined ? undefined : current[property];
+    current = isASTNode(inner) ? inner : undefined;
+  }
+  return chain;
+}
+
 // src/transform/needs-blank-line.ts
 var CONTROL_FLOW_TYPES = new Set([
   "IfStatement",
@@ -54,19 +75,30 @@ function needsBlankLine(container, prev, next) {
   if (container.type === "ClassBody") {
     return true;
   }
-  if (isVarDecl(prev) && !isVarDecl(next) || isUsingDecl(prev) && !isUsingDecl(next)) {
+  if (isRunEnd(prev, next) || next.type === "ReturnStatement" || isFnOrClassDecl(prev)) {
     return true;
   }
-  if (next.type === "ReturnStatement") {
+  if (isTypeDecl(prev) || isTypeDecl(next)) {
     return true;
   }
-  if (isFnOrClassDecl(prev)) {
+  return isNewHeaded(prev) !== isNewHeaded(next) || isAwaitHeaded(prev) !== isAwaitHeaded(next) || isKindBoundary(prev, next) || CONTROL_FLOW_TYPES.has(next.type) || CONTROL_FLOW_TYPES.has(prev.type);
+}
+function isRunEnd(prev, next) {
+  return isVarDecl(prev) && !isVarDecl(next) || isUsingDecl(prev) && !isUsingDecl(next) || isDirective(prev) && !isDirective(next) || prev.type === "ImportDeclaration" && next.type !== "ImportDeclaration";
+}
+function isDirective(node) {
+  return typeof node["directive"] === "string";
+}
+var TYPE_DECL_TYPES = new Set(["TSTypeAliasDeclaration", "TSInterfaceDeclaration"]);
+function isTypeDecl(node) {
+  if (TYPE_DECL_TYPES.has(node.type)) {
     return true;
   }
-  return isNewHeaded(prev) !== isNewHeaded(next) || isAwaitHeaded(prev) !== isAwaitHeaded(next) || isKindBoundary(prev, next) || CONTROL_FLOW_TYPES.has(next.type) || CONTROL_FLOW_TYPES.has(prev.type);
+  const declaration = node.declaration;
+  return node.type === "ExportNamedDeclaration" && isASTNode(declaration) && TYPE_DECL_TYPES.has(declaration.type);
 }
 function isNewHeaded(node) {
-  return getStatementValues(node).some((value) => getExpressionHead(value).type === "NewExpression");
+  return getStatementValues(node).some((value) => collectHeadChain(value).at(-1)?.type === "NewExpression");
 }
 function getStatementValues(node) {
   if (node.type === "VariableDeclaration") {
@@ -82,44 +114,11 @@ function getStatementValues(node) {
   }
   return [expression];
 }
-var HEAD_PROPERTY = {
-  CallExpression: "callee",
-  MemberExpression: "object",
-  ChainExpression: "expression",
-  AwaitExpression: "argument",
-  TSNonNullExpression: "expression",
-  ParenthesizedExpression: "expression"
-};
-function getExpressionHead(node) {
-  let current = node;
-  let property = HEAD_PROPERTY[current.type];
-  while (property !== undefined) {
-    const inner = current[property];
-    if (!isASTNode(inner)) {
-      break;
-    }
-    current = inner;
-    property = HEAD_PROPERTY[current.type];
-  }
-  return current;
-}
 function isAwaitHeaded(node) {
   if (node.type === "VariableDeclaration" && node.kind === "await using") {
     return true;
   }
-  return getStatementValues(node).some((value) => hasAwaitInHeadChain(value));
-}
-function hasAwaitInHeadChain(node) {
-  let current = node;
-  while (current !== undefined) {
-    if (current.type === "AwaitExpression") {
-      return true;
-    }
-    const property = HEAD_PROPERTY[current.type];
-    const inner = property === undefined ? undefined : current[property];
-    current = isASTNode(inner) ? inner : undefined;
-  }
-  return false;
+  return getStatementValues(node).some((value) => collectHeadChain(value).some((link) => link.type === "AwaitExpression"));
 }
 var CALL_TYPES = ["CallExpression", "AwaitExpression"];
 var MUTATION_TYPES = ["AssignmentExpression", "UpdateExpression"];
@@ -136,10 +135,20 @@ function getStatementKind(node) {
     return "declaration";
   }
   if (isExpressionStatementOf(node, CALL_TYPES)) {
-    return "call";
+    return pickCallKind(node);
   }
   return isExpressionStatementOf(node, MUTATION_TYPES) ? "mutation" : null;
 }
+function pickCallKind(node) {
+  const expression = node["expression"];
+  const callee = isASTNode(expression) ? findDeepestCallee(expression) : null;
+  return callee?.type === "MemberExpression" ? "method-call" : "bare-call";
+}
+function findDeepestCallee(expression) {
+  const deepestCall = collectHeadChain(expression).findLast((link) => link.type === "CallExpression");
+  const callee = deepestCall?.["callee"];
+  return isASTNode(callee) ? callee : null;
+}
 function isExpressionStatementOf(node, types) {
   const expression = node["expression"];
   return node.type === "ExpressionStatement" && isASTNode(expression) && types.includes(expression.type);
@@ -163,12 +172,12 @@ function isFnOrClassDecl(node) {
 }
 
 // src/transform/plan-gap-edit.ts
-function planGapEdit(file, prev, next) {
-  const gap = buildGap(file, prev, next);
+function planGapEdit(input) {
+  const gap = buildGap(input.file, input.prev, input.next);
   if (!isSafeToResize(gap)) {
     return null;
   }
-  return planBlankLineEdit(gap);
+  return input.pad ? planBlankLineEdit(gap) : planCollapseEdit(gap);
 }
 function buildGap(file, prev, next) {
   const start = getNodeEnd(prev);
@@ -250,6 +259,19 @@ function planWhitespaceGap(gap, gapStart, gapEnd) {
 function countNewlines(s) {
   return (s.match(/\n/gu) ?? []).length;
 }
+function planCollapseEdit(gap) {
+  if (gap.comments.length > 0) {
+    return null;
+  }
+  const text = gap.src.slice(gap.start, gap.end);
+  if (countNewlines(text) < MIN_NEWLINES) {
+    return null;
+  }
+  const indent = text.slice(text.lastIndexOf(`
+`) + 1);
+  return { start: gap.start, end: gap.end, replacement: `
+${indent}` };
+}
 
 // src/transform/build-edits-from-ast.ts
 function buildEditsFromAST(src, parsed) {
@@ -282,8 +304,9 @@ function buildPairEdits(file, container, body) {
   for (let i = 0;i < body.length - 1; i++) {
     const prev = body[i];
     const next = body[i + 1];
-    if (prev !== undefined && next !== undefined && !isImportPair(prev, next) && (needsBlankLine(container, prev, next) || isMultiline(file.src, prev) || isMultiline(file.src, next))) {
-      const edit = planGapEdit(file, prev, next);
+    if (prev !== undefined && next !== undefined && !isImportPair(prev, next)) {
+      const pad = needsBlankLine(container, prev, next) || isMultiline(file.src, prev) || isMultiline(file.src, next);
+      const edit = planGapEdit({ file, prev, next, pad });
       if (edit !== null) {
         edits.push(edit);
       }

package/dist/transform/collect-head-chain.d.ts

@@ -0,0 +1,9 @@
+import type { ASTNode } from '../types.ts';
+/**
+ * The nodes on the walk from an expression to its head, outermost first and
+ * ending at the head itself — `(await f()).prop` yields the member access,
+ * the parenthesis, the await, the call, and finally `f`. Nodes outside the
+ * walk (call arguments, ternary branches) never appear, so a scan of the
+ * chain sees only what a reader meets before the expression's first token.
+ */
+export declare function collectHeadChain(expression: ASTNode): ASTNode[];

package/dist/transform/needs-blank-line.d.ts

@@ -1,11 +1,13 @@
 import type { ASTNode } from '../types.ts';
 /**
  * The "always" rules: a blank line between class members, after a var or
- * using block before a statement of any other kind, before a return, after a
- * function/class declaration, on both sides of a control-flow block — its
- * closing brace ends a visual unit just like its opening keyword starts one —
- * and at the boundary between statement kinds: call vs mutation,
- * instantiation vs anything else, and awaited vs non-awaited. There are no
- * "never" rules, so any match means one blank.
+ * using block before a statement of any other kind, after a directive
+ * prologue, after the last import of a block, before a return, after a
+ * function/class declaration, on both sides of a type alias or interface
+ * declaration, on both sides of a control-flow block — its closing brace
+ * ends a visual unit just like its opening keyword starts one —
+ * and at the boundary between statement kinds: bare call vs method call vs
+ * mutation, instantiation vs anything else, and awaited vs non-awaited. Any
+ * match means exactly one blank line; a pair matching no rule sits flush.
  */
 export declare function needsBlankLine(container: ASTNode, prev: ASTNode, next: ASTNode): boolean;

package/dist/transform/plan-gap-edit.d.ts

@@ -1,8 +1,20 @@
 import type { ASTNode, Edit, SourceFile } from '../types.ts';
+/**
+ * A pair of adjacent statements in a file and the gap shape they take: one
+ * blank line between them when `pad` is set, none otherwise.
+ */
+export interface GapEditInput {
+    readonly file: SourceFile;
+    readonly prev: ASTNode;
+    readonly next: ASTNode;
+    readonly pad: boolean;
+}
 /**
  * Plans the single whitespace splice that gives the gap between two statements
- * exactly one blank line, or null when the gap is already compliant or unsafe
- * to touch. Comment positions come from the parser rather than lexical
- * scanning, so comment-lookalike text can't mislead the classification.
+ * its target shape, or null when the gap is already compliant or unsafe to
+ * touch. Collapsing never crosses a comment: prose between statements marks
+ * grouping the padding rules can't see, so a comment-bearing gap only ever
+ * grows. Comment positions come from the parser rather than lexical scanning,
+ * so comment-lookalike text can't mislead the classification.
  */
-export declare function planGapEdit(file: SourceFile, prev: ASTNode, next: ASTNode): Edit | null;
+export declare function planGapEdit(input: GapEditInput): Edit | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/format-codemod",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Enforce blank-line padding conventions in TypeScript via a fast text-splice codemod",
   "license": "MIT",
   "repository": {