@workos/oagen-emitters 0.15.2 → 0.16.0

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { t as workosEmittersPlugin } from "./plugin-Xkr83G9A.mjs";
+import { t as workosEmittersPlugin } from "./plugin-DuB1UozS.mjs";
 export { workosEmittersPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.15.2",
+  "version": "0.16.0",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -42,8 +42,8 @@
     "@commitlint/config-conventional": "^21.0.2",
     "@types/node": "^25.9.1",
     "husky": "^9.1.7",
-    "oxfmt": "^0.52.0",
-    "oxlint": "^1.67.0",
+    "oxfmt": "^0.53.0",
+    "oxlint": "^1.68.0",
     "prettier": "^3.8.3",
     "tsdown": "^0.22.1",
     "tsx": "^4.22.4",
@@ -54,6 +54,6 @@
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.21.1"
+    "@workos/oagen": "^0.22.0"
   }
 }

package/src/dotnet/naming.ts

@@ -149,7 +149,7 @@ function wordsMatch(left: string, right: string): boolean {
   return singularize(left.toLowerCase()) === singularize(right.toLowerCase());
 }
 
-function trimMountedResourceFromMethod(method: string, mountName: string): string {
+export function trimMountedResourceFromMethod(method: string, mountName: string): string {
   const methodWords = splitPascalWords(method);
   if (methodWords.length < 2) return method;
 

package/src/go/naming.ts

@@ -157,7 +157,7 @@ function wordsMatch(left: string, right: string): boolean {
   return singularize(left.toLowerCase()) === singularize(right.toLowerCase());
 }
 
-function trimMountedResourceFromMethod(method: string, mountName: string): string {
+export function trimMountedResourceFromMethod(method: string, mountName: string): string {
   const methodWords = splitPascalWords(method);
   if (methodWords.length < 2) return method;
 

package/src/index.ts

@@ -18,3 +18,18 @@ export { dotnetExtractor } from './compat/extractors/dotnet.js';
 export { elixirExtractor } from './compat/extractors/elixir.js';
 
 export { workosEmittersPlugin } from './plugin.js';
+
+// Language-specific snippet emitters. The framework primitives
+// (SnippetEmitter, runSnippetEmitters, snippetResultsToFiles,
+// createExampleBuilder, collectSnippetArgs, collectWrapperArgs, etc.)
+// live upstream in @workos/oagen — consumers import those from there.
+export {
+  rubySnippetEmitter,
+  pythonSnippetEmitter,
+  phpSnippetEmitter,
+  goSnippetEmitter,
+  dotnetSnippetEmitter,
+  kotlinSnippetEmitter,
+  rustSnippetEmitter,
+  workosSnippetsPlugin,
+} from './snippets/index.js';

package/src/node/tests.ts

@@ -1,6 +1,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import type { ApiSpec, Service, Operation, Model, TypeRef, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type {
+  ApiSpec,
+  Service,
+  Operation,
+  Model,
+  TypeRef,
+  Parameter,
+  EmitterContext,
+  GeneratedFile,
+} from '@workos/oagen';
 import { planOperation, toCamelCase, toPascalCase } from '@workos/oagen';
 import { unwrapListModel, ID_PREFIXES } from './fixtures.js';
 import {
@@ -333,6 +342,20 @@ function pathParamTestValue(param: { type: TypeRef; name?: string } | undefined,
   return 'test_id';
 }
 
+function queryParamTestValue(param: Parameter, modelMap?: Map<string, Model>): string {
+  if (param.example !== undefined) {
+    if (Array.isArray(param.example)) {
+      return `[${param.example.map((v: unknown) => (typeof v === 'string' ? `'${v}'` : String(v))).join(', ')}]`;
+    }
+    const isDateTime = param.type.kind === 'primitive' && param.type.format === 'date-time';
+    if (isDateTime && typeof param.example === 'string') {
+      return `new Date('${param.example}')`;
+    }
+    return typeof param.example === 'string' ? `'${param.example}'` : String(param.example);
+  }
+  return fixtureValueForType(param.type, param.name, 'Options', modelMap) ?? "'test'";
+}
+
 /** Build test arguments for all path params (handles multiple path params). */
 function buildTestPathArgs(op: Operation): string {
   // Detect path template variables (may be more than op.pathParams if spec is incomplete)
@@ -372,7 +395,10 @@ function renderPaginatedTest(
   const optionsArg = buildOptionsObjectTestArg(op, plan, baselineMethod, modelMap, ctx);
   const baselineItemType = autoPaginatableItemType(baselineMethod?.returnType);
   const generatedItemType = ctx ? resolveInterfaceName(itemModelName, ctx) : null;
-  const skipFieldAssertions = Boolean(baselineItemType && generatedItemType && baselineItemType !== generatedItemType);
+  const baselineHasNonPaginatableReturn = Boolean(baselineMethod?.returnType && !baselineItemType);
+  const skipFieldAssertions =
+    baselineHasNonPaginatableReturn ||
+    Boolean(baselineItemType && generatedItemType && baselineItemType !== generatedItemType);
 
   lines.push("    it('returns paginated results', async () => {");
   lines.push(`      fetchOnce(list${itemModelName}Fixture);`);
@@ -649,7 +675,7 @@ function buildOptionsObjectTestArg(
     : op.queryParams;
   for (const param of queryParams) {
     const localName = fieldName(param.name);
-    const value = fixtureValueForType(param.type, param.name, 'Options', modelMap) ?? "'test'";
+    const value = queryParamTestValue(param, modelMap);
     entries.push(`${localName}: ${value}`);
   }
 

package/src/snippets/dotnet.ts

@@ -0,0 +1,159 @@
+import type { EmitterContext, ExampleBuilder, ResolvedOperation, SnippetArg, SnippetEmitter } from '@workos/oagen';
+import { collectSnippetArgs, collectWrapperArgs } from '@workos/oagen';
+import {
+  appendAsyncSuffix,
+  className,
+  fieldName,
+  methodName,
+  trimMountedResourceFromMethod,
+} from '../dotnet/naming.js';
+
+const INDENT = '    ';
+
+export const dotnetSnippetEmitter: SnippetEmitter = {
+  language: 'dotnet',
+  fileExtension: 'cs',
+
+  renderOperation(resolved, ctx, examples) {
+    if (resolved.urlBuilder) return null;
+
+    // Mirror the .NET SDK's naming pipeline directly from the resolved op:
+    // PascalCase → trim mount-target resource → append Async. We avoid
+    // calling back into resolveMethodName so the snippet emitter does not
+    // re-validate the whole resolved-ops set on every invocation.
+    const rawMethodName =
+      resolved.wrappers && resolved.wrappers.length > 0 ? resolved.wrappers[0]!.name : resolved.methodName;
+    const stem = trimMountedResourceFromMethod(methodName(rawMethodName), resolved.mountOn);
+    const method = appendAsyncSuffix(stem);
+
+    return renderCall(resolved, ctx, examples, method);
+  },
+};
+
+function renderCall(
+  resolved: ResolvedOperation,
+  ctx: EmitterContext,
+  examples: ExampleBuilder,
+  method: string,
+): string {
+  const accessor = className(resolved.mountOn);
+  // Options class follows the `{Resource}{Method}Options` convention used by
+  // the SDK (e.g. OrganizationsCreateOptions). The method here already had its
+  // resource prefix trimmed and Async suffix appended, so reconstruct.
+  const stem = method.replace(/Async$/, '');
+  const optsType = `${accessor}${stem}Options`;
+
+  let args: SnippetArg[];
+  let pathArgs: SnippetArg[];
+  let optionsArgs: SnippetArg[];
+
+  if (resolved.wrappers && resolved.wrappers.length > 0) {
+    args = collectWrapperArgs(resolved.wrappers[0]!, ctx, examples);
+    pathArgs = [];
+    optionsArgs = args;
+  } else {
+    const collected = collectSnippetArgs(resolved, ctx, examples);
+    args = collected.args;
+    pathArgs = args.filter((a) => a.source === 'path');
+    optionsArgs = args.filter((a) => a.source !== 'path');
+  }
+
+  const lines: string[] = [];
+  lines.push('using WorkOS;');
+  lines.push('');
+  lines.push('var client = new WorkOSClient(new WorkOSOptions');
+  lines.push('{');
+  lines.push(`${INDENT}ApiKey = "sk_example_123456789",`);
+  lines.push(`${INDENT}ClientId = "client_123456789",`);
+  lines.push('});');
+  lines.push('');
+
+  const callParts: string[] = [];
+  for (const p of pathArgs) callParts.push(renderValue(p.value));
+  if (optionsArgs.length > 0) callParts.push(renderOptions(optsType, optionsArgs));
+
+  const lhs = `await client.${accessor}.${method}`;
+  if (callParts.length === 0) {
+    lines.push(`${lhs}();`);
+  } else if (callParts.length === 1) {
+    lines.push(`${lhs}(${indentContinuationLines(callParts[0]!, INDENT)});`);
+  } else {
+    lines.push(`${lhs}(`);
+    for (let i = 0; i < callParts.length; i++) {
+      const trailing = i < callParts.length - 1 ? ',' : '';
+      lines.push(`${INDENT}${indentContinuationLines(callParts[i]!, INDENT)}${trailing}`);
+    }
+    lines.push(');');
+  }
+
+  return lines.join('\n');
+}
+
+function renderOptions(typeName: string, args: SnippetArg[]): string {
+  const lines: string[] = [`new ${typeName}`, '{'];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]!;
+    const field = fieldName(a.wireName);
+    const value = renderValue(a.value);
+    const trailing = i < args.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}${field} = ${indentContinuationLines(value, INDENT)}${trailing}`);
+  }
+  lines.push('}');
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// C# literal rendering
+// ---------------------------------------------------------------------------
+
+function renderValue(value: unknown): string {
+  if (value === null || value === undefined) return 'null';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'string') return csharpString(value);
+  if (Array.isArray(value)) return renderArray(value);
+  if (typeof value === 'object') return renderDict(value as Record<string, unknown>);
+  return 'null';
+}
+
+function csharpString(s: string): string {
+  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function renderArray(items: unknown[]): string {
+  if (items.length === 0) return 'new[] { }';
+  const rendered = items.map((v) => renderValue(v));
+  const oneline = `new[] { ${rendered.join(', ')} }`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['new[]', '{'];
+  for (let i = 0; i < rendered.length; i++) {
+    const trailing = i < rendered.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}${indentContinuationLines(rendered[i]!, INDENT)}${trailing}`);
+  }
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function renderDict(obj: Record<string, unknown>): string {
+  // Plain dictionary literal — the dotnet SDK exposes models, but the snippet
+  // doesn't know which model class corresponds to each nested object. Emit a
+  // Dictionary<string, object> initializer that the SDK serializer can handle
+  // or a developer can replace with the typed model.
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return 'new Dictionary<string, object>()';
+  const rendered = entries.map(([k, v]) => ({ key: k, value: renderValue(v) }));
+  const lines: string[] = ['new Dictionary<string, object>', '{'];
+  for (let i = 0; i < rendered.length; i++) {
+    const e = rendered[i]!;
+    const trailing = i < rendered.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}{ "${e.key}", ${indentContinuationLines(e.value, INDENT)} }${trailing}`);
+  }
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function indentContinuationLines(s: string, indent: string): string {
+  if (!s.includes('\n')) return s;
+  const lines = s.split('\n');
+  return lines.map((line, i) => (i === 0 ? line : `${indent}${line}`)).join('\n');
+}

package/src/snippets/go.ts

@@ -0,0 +1,148 @@
+import type { EmitterContext, ExampleBuilder, ResolvedOperation, SnippetArg, SnippetEmitter } from '@workos/oagen';
+import { collectSnippetArgs, collectWrapperArgs } from '@workos/oagen';
+import { className, fieldName, methodName, trimMountedResourceFromMethod } from '../go/naming.js';
+
+const INDENT = '\t';
+
+export const goSnippetEmitter: SnippetEmitter = {
+  language: 'go',
+  fileExtension: 'go',
+
+  renderOperation(resolved, ctx, examples) {
+    if (resolved.urlBuilder) return null;
+
+    // Mirror the Go SDK's naming pipeline: PascalCase the resolved method
+    // name (or the wrapper name for split ops), then trim any mount-target
+    // resource words from the end so `CreateOrganization` on `Organizations`
+    // becomes `Create`. We compute these directly from the resolved op so
+    // the snippet emitter does not depend on a fresh `buildResolvedLookup`
+    // (which would re-validate the entire spec for uniqueness).
+    const rawMethodName =
+      resolved.wrappers && resolved.wrappers.length > 0 ? resolved.wrappers[0]!.name : resolved.methodName;
+    const method = trimMountedResourceFromMethod(methodName(rawMethodName), resolved.mountOn);
+
+    return renderCall(resolved, ctx, examples, method);
+  },
+};
+
+function renderCall(
+  resolved: ResolvedOperation,
+  ctx: EmitterContext,
+  examples: ExampleBuilder,
+  method: string,
+): string {
+  const accessorMethod = className(resolved.mountOn);
+  const optsTypeName = `${accessorMethod}${method}Params`;
+
+  let args: SnippetArg[];
+  let pathArgs: SnippetArg[];
+  let bodyAndQueryArgs: SnippetArg[];
+
+  if (resolved.wrappers && resolved.wrappers.length > 0) {
+    args = collectWrapperArgs(resolved.wrappers[0]!, ctx, examples);
+    pathArgs = [];
+    bodyAndQueryArgs = args;
+  } else {
+    const collected = collectSnippetArgs(resolved, ctx, examples);
+    args = collected.args;
+    pathArgs = args.filter((a) => a.source === 'path');
+    bodyAndQueryArgs = args.filter((a) => a.source !== 'path');
+  }
+
+  const lines: string[] = [];
+  lines.push('package main');
+  lines.push('');
+  lines.push('import (');
+  lines.push(`${INDENT}"context"`);
+  lines.push('');
+  lines.push(`${INDENT}"github.com/workos/workos-go/v9"`);
+  lines.push(')');
+  lines.push('');
+  lines.push('func main() {');
+  lines.push(`${INDENT}client := workos.NewClient("sk_example_123456789")`);
+  lines.push('');
+
+  // Build the method call. Go SDK methods take (ctx, positional path params..., *OptsStruct).
+  const callParts: string[] = ['context.Background()'];
+  for (const p of pathArgs) {
+    callParts.push(renderValue(p.value));
+  }
+
+  if (bodyAndQueryArgs.length === 0) {
+    lines.push(`${INDENT}_, err := client.${accessorMethod}().${method}(${callParts.join(', ')})`);
+  } else {
+    const optsLines = buildOptsStruct(optsTypeName, bodyAndQueryArgs);
+    callParts.push(optsLines);
+    const joined = callParts.length === 2 ? callParts.join(', ') : callParts.join(', ');
+    lines.push(`${INDENT}_, err := client.${accessorMethod}().${method}(${joined})`);
+  }
+  lines.push(`${INDENT}if err != nil {`);
+  lines.push(`${INDENT}${INDENT}panic(err)`);
+  lines.push(`${INDENT}}`);
+  lines.push('}');
+
+  return lines.join('\n');
+}
+
+function buildOptsStruct(typeName: string, args: SnippetArg[]): string {
+  const lines: string[] = [`&workos.${typeName}{`];
+  for (const a of args) {
+    const field = fieldName(a.wireName);
+    const value = renderValue(a.value);
+    const indentedValue = indentContinuationLines(value, `${INDENT}${INDENT}`);
+    lines.push(`${INDENT}${INDENT}${field}: ${indentedValue},`);
+  }
+  lines.push(`${INDENT}}`);
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Go literal rendering
+// ---------------------------------------------------------------------------
+
+function renderValue(value: unknown): string {
+  if (value === null || value === undefined) return 'nil';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'string') return goString(value);
+  if (Array.isArray(value)) return renderSlice(value);
+  if (typeof value === 'object') return renderStruct(value as Record<string, unknown>);
+  return 'nil';
+}
+
+function goString(s: string): string {
+  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function renderSlice(items: unknown[]): string {
+  if (items.length === 0) return '[]any{}';
+  const rendered = items.map((v) => renderValue(v));
+  const oneline = `[]any{${rendered.join(', ')}}`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['[]any{'];
+  for (const r of rendered) {
+    lines.push(`${INDENT}${indentContinuationLines(r, INDENT)},`);
+  }
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function renderStruct(obj: Record<string, unknown>): string {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return 'map[string]any{}';
+  const rendered = entries.map(([k, v]) => ({ key: k, value: renderValue(v) }));
+  const oneline = `map[string]any{${rendered.map((e) => `"${e.key}": ${e.value}`).join(', ')}}`;
+  if (oneline.length <= 80 && rendered.every((e) => !e.value.includes('\n'))) return oneline;
+  const lines: string[] = ['map[string]any{'];
+  for (const e of rendered) {
+    lines.push(`${INDENT}"${e.key}": ${indentContinuationLines(e.value, INDENT)},`);
+  }
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function indentContinuationLines(s: string, indent: string): string {
+  if (!s.includes('\n')) return s;
+  const lines = s.split('\n');
+  return lines.map((line, i) => (i === 0 ? line : `${indent}${line}`)).join('\n');
+}

package/src/snippets/index.ts

@@ -0,0 +1,8 @@
+export { rubySnippetEmitter } from './ruby.js';
+export { pythonSnippetEmitter } from './python.js';
+export { phpSnippetEmitter } from './php.js';
+export { goSnippetEmitter } from './go.js';
+export { dotnetSnippetEmitter } from './dotnet.js';
+export { kotlinSnippetEmitter } from './kotlin.js';
+export { rustSnippetEmitter } from './rust.js';
+export { workosSnippetsPlugin } from './plugin.js';

package/src/snippets/kotlin.ts

@@ -0,0 +1,144 @@
+import type { EmitterContext, ExampleBuilder, ResolvedOperation, SnippetArg, SnippetEmitter } from '@workos/oagen';
+import { collectSnippetArgs, collectWrapperArgs } from '@workos/oagen';
+import { apiClassName, methodName, packageSegment, propertyName } from '../kotlin/naming.js';
+
+const INDENT = '    ';
+
+/**
+ * Emits Java-syntax snippets (rendered as `.java`) backed by the Kotlin SDK's
+ * naming so JVM callers see the same method and options names whether they
+ * write Kotlin or Java. The WorkOS docs render the `.java` extension because
+ * Java is the most common JVM consumer; Kotlin call sites would look almost
+ * identical apart from `var`/`val` and named-argument syntax.
+ */
+export const kotlinSnippetEmitter: SnippetEmitter = {
+  language: 'java',
+  fileExtension: 'java',
+
+  renderOperation(resolved, ctx, examples) {
+    if (resolved.urlBuilder) return null;
+
+    const method =
+      resolved.wrappers && resolved.wrappers.length > 0
+        ? methodName(resolved.wrappers[0]!.name)
+        : methodName(resolved.methodName);
+
+    return renderCall(resolved, ctx, examples, method);
+  },
+};
+
+function renderCall(
+  resolved: ResolvedOperation,
+  ctx: EmitterContext,
+  examples: ExampleBuilder,
+  method: string,
+): string {
+  const apiClass = apiClassName(resolved.mountOn);
+  const accessor = propertyName(resolved.mountOn);
+  const optionsType = `${methodName(
+    resolved.wrappers && resolved.wrappers.length > 0 ? resolved.wrappers[0]!.name : resolved.methodName,
+  )}Options`;
+  const optionsTypeCapitalized = optionsType[0]!.toUpperCase() + optionsType.slice(1);
+  const apiSubPackage = packageSegment(resolved.mountOn);
+
+  let args: SnippetArg[];
+  let pathArgs: SnippetArg[];
+  let optionsArgs: SnippetArg[];
+
+  if (resolved.wrappers && resolved.wrappers.length > 0) {
+    args = collectWrapperArgs(resolved.wrappers[0]!, ctx, examples);
+    pathArgs = [];
+    optionsArgs = args;
+  } else {
+    const collected = collectSnippetArgs(resolved, ctx, examples);
+    args = collected.args;
+    pathArgs = args.filter((a) => a.source === 'path');
+    optionsArgs = args.filter((a) => a.source !== 'path');
+  }
+
+  const lines: string[] = [];
+  lines.push('import com.workos.WorkOS;');
+  if (optionsArgs.length > 0) {
+    lines.push(`import com.workos.${apiSubPackage}.${apiClass}Api.${optionsTypeCapitalized};`);
+  }
+  lines.push('');
+  lines.push('WorkOS workos = new WorkOS("sk_example_123456789");');
+  lines.push('');
+
+  const callParts: string[] = pathArgs.map((p) => renderValue(p.value));
+
+  if (optionsArgs.length > 0) {
+    lines.push(`${optionsTypeCapitalized} options = ${optionsTypeCapitalized}.builder()`);
+    for (const a of optionsArgs) {
+      const prop = propertyName(a.wireName);
+      const value = renderValue(a.value);
+      const indentedValue = indentContinuationLines(value, INDENT);
+      lines.push(`${INDENT}.${prop}(${indentedValue})`);
+    }
+    lines.push(`${INDENT}.build();`);
+    lines.push('');
+    callParts.push('options');
+  }
+
+  if (callParts.length === 0) {
+    lines.push(`workos.${accessor}.${method}();`);
+  } else {
+    lines.push(`workos.${accessor}.${method}(${callParts.join(', ')});`);
+  }
+
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Java literal rendering
+// ---------------------------------------------------------------------------
+
+function renderValue(value: unknown): string {
+  if (value === null || value === undefined) return 'null';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'string') return javaString(value);
+  if (Array.isArray(value)) return renderList(value);
+  if (typeof value === 'object') return renderMap(value as Record<string, unknown>);
+  return 'null';
+}
+
+function javaString(s: string): string {
+  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function renderList(items: unknown[]): string {
+  if (items.length === 0) return 'List.of()';
+  const rendered = items.map((v) => renderValue(v));
+  const oneline = `List.of(${rendered.join(', ')})`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['List.of('];
+  for (let i = 0; i < rendered.length; i++) {
+    const trailing = i < rendered.length - 1 ? ',' : '';
+    lines.push(`${INDENT}${indentContinuationLines(rendered[i]!, INDENT)}${trailing}`);
+  }
+  lines.push(')');
+  return lines.join('\n');
+}
+
+function renderMap(obj: Record<string, unknown>): string {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return 'Map.of()';
+  const rendered = entries.map(([k, v]) => ({ key: k, value: renderValue(v) }));
+  const oneline = `Map.of(${rendered.map((e) => `"${e.key}", ${e.value}`).join(', ')})`;
+  if (oneline.length <= 80 && rendered.every((e) => !e.value.includes('\n'))) return oneline;
+  const lines: string[] = ['Map.of('];
+  for (let i = 0; i < rendered.length; i++) {
+    const e = rendered[i]!;
+    const trailing = i < rendered.length - 1 ? ',' : '';
+    lines.push(`${INDENT}"${e.key}", ${indentContinuationLines(e.value, INDENT)}${trailing}`);
+  }
+  lines.push(')');
+  return lines.join('\n');
+}
+
+function indentContinuationLines(s: string, indent: string): string {
+  if (!s.includes('\n')) return s;
+  const lines = s.split('\n');
+  return lines.map((line, i) => (i === 0 ? line : `${indent}${line}`)).join('\n');
+}