@typespec/http-server-js 0.58.0-alpha.13-dev.3 → 0.58.0-alpha.13-dev.6

package/src/http/server/index.ts

@@ -41,6 +41,7 @@ import { module as headerHelpers } from "../../../generated-defs/helpers/header.
 import { module as httpHelpers } from "../../../generated-defs/helpers/http.js";
 import { getJsScalar } from "../../common/scalar.js";
 import { requiresJsonSerialization } from "../../common/serialization/json.js";
+import { getFullyQualifiedTypeName } from "../../util/name.js";
 
 const DEFAULT_CONTENT_TYPE = "application/json";
 
@@ -296,7 +297,7 @@ function* emitRawServerOperation(
 
         break;
       }
-      case "multipart/form-data":
+      case "multipart/form-data": {
         if (body.bodyKind === "multipart") {
           yield* indent(
             emitMultipart(ctx, module, operation, body, names.ctx, bodyName, bodyTypeName),
@@ -305,7 +306,88 @@ function* emitRawServerOperation(
           yield* indent(emitMultipartLegacy(names.ctx, bodyName, bodyTypeName));
         }
         break;
+      }
+      case "text/plain": {
+        const string = ctx.program.checker.getStdType("string");
+        const [assignable] = ctx.program.checker.isTypeAssignableTo(
+          body.type,
+          string,
+          body.property ?? body.type,
+        );
+        if (!assignable) {
+          const name =
+            ("namespace" in body.type &&
+              body.type.namespace &&
+              getFullyQualifiedTypeName(body.type)) ||
+            ("name" in body.type && typeof body.type.name === "string" && body.type.name) ||
+            "<unknown>";
+          reportDiagnostic(ctx.program, {
+            code: "unrecognized-media-type",
+            target: body.property ?? body.type,
+            format: {
+              mediaType: contentType,
+              type: name,
+            },
+          });
+        }
+
+        yield `  const ${bodyName} = await new Promise(function parse${bodyNameCase.pascalCase}(resolve, reject) {`;
+        yield `    const chunks: Array<Buffer> = [];`;
+        yield `    ${names.ctx}.request.on("data", function appendChunk(chunk) { chunks.push(chunk); });`;
+        yield `    ${names.ctx}.request.on("end", function finalize() {`;
+        yield `      try {`;
+        yield `        const body = Buffer.concat(chunks).toString();`;
+        yield `        resolve(body);`;
+        yield `      } catch (e) {`;
+        yield `        ${names.ctx}.errorHandlers.onInvalidRequest(`;
+        yield `          ${names.ctx},`;
+        yield `          ${JSON.stringify(operation.path)},`;
+        yield `          "invalid text in request body",`;
+        yield `        );`;
+        yield `        reject(e);`;
+        yield `      }`;
+        yield `    });`;
+        yield `    ${names.ctx}.request.on("error", reject);`;
+        yield `  }) as string;`;
+        yield "";
+        break;
+      }
+      case "application/octet-stream":
       default:
+        {
+          if (!ctx.program.checker.isStdType(body.type, "bytes")) {
+            const name =
+              ("namespace" in body.type &&
+                body.type.namespace &&
+                getFullyQualifiedTypeName(body.type)) ||
+              ("name" in body.type && typeof body.type.name === "string" && body.type.name) ||
+              "<unknown>";
+
+            reportDiagnostic(ctx.program, {
+              code: "unrecognized-media-type",
+              target: body.property ?? body.type,
+              format: {
+                mediaType: contentType,
+                type: name,
+              },
+            });
+          }
+          yield `  const ${bodyName} = await new Promise(function parse${bodyNameCase.pascalCase}(resolve, reject) {`;
+          yield `    const chunks: Array<Buffer> = [];`;
+          yield `    ${names.ctx}.request.on("data", function appendChunk(chunk) { chunks.push(chunk); });`;
+          yield `    ${names.ctx}.request.on("end", function finalize() {`;
+          yield `      try {`;
+          yield `        const body = Buffer.concat(chunks);`;
+          yield `        resolve(body);`;
+          yield `      } catch (e) {`;
+          yield `        reject(e);`;
+          yield `      }`;
+          yield `    });`;
+          yield `    ${names.ctx}.request.on("error", reject);`;
+          yield `  }) as Buffer;`;
+          yield "";
+          break;
+        }
         throw new UnimplementedError(`request deserialization for content-type: '${contentType}'`);
     }
 

package/src/http/server/router.ts

@@ -7,7 +7,8 @@ import {
   HttpService,
   HttpVerb,
   OperationContainer,
-  getHttpOperation,
+  getHeaderFieldName,
+  isHeader,
 } from "@typespec/http";
 import {
   createOrGetModuleForNamespace,
@@ -22,9 +23,7 @@ import { HttpContext } from "../index.js";
 
 import { module as headerHelpers } from "../../../generated-defs/helpers/header.js";
 import { module as routerHelper } from "../../../generated-defs/helpers/router.js";
-import { parseHeaderValueParameters } from "../../helpers/header.js";
-import { reportDiagnostic } from "../../lib.js";
-import { UnimplementedError } from "../../util/error.js";
+import { differentiateModelTypes, writeCodeTree } from "../../util/differentiate.js";
 
 /**
  * Emit a router for the HTTP operations defined in a given service.
@@ -261,7 +260,9 @@ function* emitRouteHandler(
 
   yield `if (path.length === 0) {`;
   if (routeTree.operations.size > 0) {
-    yield* indent(emitRouteOperationDispatch(ctx, routeHandlers, routeTree.operations, backends));
+    yield* indent(
+      emitRouteOperationDispatch(ctx, routeHandlers, routeTree.operations, backends, module),
+    );
   } else {
     // Not found
     yield `  return ${onRouteNotFound}(ctx);`;
@@ -318,6 +319,7 @@ function* emitRouteOperationDispatch(
   routeHandlers: string,
   operations: Map<HttpVerb, RouteOperation[]>,
   backends: Map<OperationContainer, [ReCase, string]>,
+  module: Module,
 ): Iterable<string> {
   yield `switch (request.method) {`;
   for (const [verb, operationList] of operations.entries()) {
@@ -339,11 +341,10 @@ function* emitRouteOperationDispatch(
       yield `    return ${routeHandlers}.${operationName}(ctx, ${backendMemberName}${parameters});`;
     } else {
       // Shared route
-      const route = getHttpOperation(ctx.program, operationList[0].operation)[0].path;
       yield `  case ${JSON.stringify(verb.toUpperCase())}:`;
       yield* indent(
         indent(
-          emitRouteOperationDispatchMultiple(ctx, routeHandlers, operationList, route, backends),
+          emitRouteOperationDispatchMultiple(ctx, routeHandlers, operationList, backends, module),
         ),
       );
     }
@@ -366,64 +367,50 @@ function* emitRouteOperationDispatchMultiple(
   ctx: HttpContext,
   routeHandlers: string,
   operations: RouteOperation[],
-  route: string,
   backends: Map<OperationContainer, [ReCase, string]>,
+  module: Module,
 ): Iterable<string> {
-  const usedContentTypes = new Set<string>();
-  const contentTypeMap = new Map<RouteOperation, string>();
+  const differentiated = differentiateModelTypes(
+    ctx,
+    module,
+    new Set(operations.map((op) => op.operation.parameters)),
+    {
+      renderPropertyName(prop): string {
+        return getHeaderFieldName(ctx.program, prop);
+      },
+      filter(prop): boolean {
+        return isHeader(ctx.program, prop);
+      },
+      else: {
+        kind: "verbatim",
+        body: [`return ctx.errorHandlers.onRequestNotFound(ctx);`],
+      },
+    },
+  );
 
-  for (const operation of operations) {
-    const [httpOperation] = getHttpOperation(ctx.program, operation.operation);
-    const operationContentType = httpOperation.parameters.parameters.find(
-      (param) => param.type === "header" && param.name.toLowerCase() === "content-type",
-    )?.param.type;
-
-    if (!operationContentType || operationContentType.kind !== "String") {
-      throw new UnimplementedError(
-        "Only string content-types are supported for route differentiation.",
+  yield* writeCodeTree(ctx, differentiated, {
+    referenceModelProperty(p) {
+      const headerName = getHeaderFieldName(ctx.program, p);
+      return `request.headers["${headerName}"]`;
+    },
+    *renderResult(type) {
+      const operation = operations.find((op) => op.operation.parameters === type)!;
+      const [backend] = backends.get(operation.container)!;
+      const operationName = keywordSafe(
+        backend.snakeCase + "_" + parseCase(operation.operation.name).snakeCase,
       );
-    }
-
-    if (usedContentTypes.has(operationContentType.value)) {
-      reportDiagnostic(ctx.program, {
-        code: "undifferentiable-route",
-        target: httpOperation.operation,
-      });
-    }
-
-    usedContentTypes.add(operationContentType.value);
-
-    contentTypeMap.set(operation, operationContentType.value);
-  }
-
-  const contentTypeName = ctx.gensym("contentType");
 
-  yield `const ${contentTypeName} = parseHeaderValueParameters(request.headers["content-type"])?.value;`;
-
-  yield `switch (${contentTypeName}) {`;
-
-  for (const [operation, contentType] of contentTypeMap.entries()) {
-    const [backend] = backends.get(operation.container)!;
-    const operationName = keywordSafe(
-      backend.snakeCase + "_" + parseCase(operation.operation.name).snakeCase,
-    );
-
-    const backendMemberName = keywordSafe(backend.camelCase);
-
-    const parameters =
-      operation.parameters.length > 0
-        ? ", " + operation.parameters.map((param) => parseCase(param.name).camelCase).join(", ")
-        : "";
-
-    const contentTypeValue = parseHeaderValueParameters(contentType).value;
+      const backendMemberName = keywordSafe(backend.camelCase);
 
-    yield `  case ${JSON.stringify(contentTypeValue)}:`;
-    yield `    return ${routeHandlers}.${operationName}(ctx, ${backendMemberName}${parameters});`;
-  }
+      const parameters =
+        operation.parameters.length > 0
+          ? ", " + operation.parameters.map((param) => parseCase(param.name).camelCase).join(", ")
+          : "";
 
-  yield `  default:`;
-  yield `    return ctx.errorHandlers.onInvalidRequest(ctx, ${JSON.stringify(route)}, \`No operation in route '${route}' matched content-type "\${${contentTypeName}}"\`);`;
-  yield "}";
+      yield `return ${routeHandlers}.${operationName}(ctx, ${backendMemberName}${parameters});`;
+    },
+    subject: "(request.headers)",
+  });
 }
 
 /**

package/src/lib.ts

@@ -148,6 +148,12 @@ export const $lib = createTypeSpecLibrary({
         default: paramMessage`Unknown encoding '${"encoding"}' to type '${"target"}' for type '${"type"}'.`,
       },
     },
+    "unrecognized-media-type": {
+      severity: "error",
+      messages: {
+        default: paramMessage`unrecognized media (MIME) type '${"mediaType"}' for type '${"type"}'.`,
+      },
+    },
   },
 });
 

package/src/scripts/scaffold/bin.mts

@@ -191,7 +191,9 @@ export async function scaffold(options: ScaffoldingOptions) {
     config.options?.["@typespec/http-server-js"]?.["emitter-output-dir"];
   const defaultOutputDir = path.resolve(path.dirname(projectYamlPath), "tsp-output");
 
-  const emitterOutputDir = emitterOutputDirTemplate.replace("{output-dir}", defaultOutputDir);
+  const emitterOutputDir =
+    emitterOutputDirTemplate?.replace("{output-dir}", defaultOutputDir) ??
+    path.join(defaultOutputDir, "@typespec", "http-server-js");
 
   const baseOutputDir = options["no-standalone"] ? cwd : path.resolve(cwd, emitterOutputDir);
   const tsConfigOutputPath = path.resolve(baseOutputDir, COMMON_PATHS.tsConfigJson);
@@ -662,7 +664,7 @@ function* emitControllerOperationHandlers(
       yield `async ${opName}(ctx: HttpContext, ${paramsDeclarationLine}): ${returnType} {`;
     }
 
-    const mockReturn = mockType(op.returnType);
+    const mockReturn = mockType(ctx, module, op.returnType);
 
     if (mockReturn === undefined) {
       importNotImplementedError = true;
@@ -789,7 +791,6 @@ function updatePackageJson(
   }
 }
 
-scaffold(parseScaffoldArguments(process.argv)).catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+export async function main() {
+  await scaffold(parseScaffoldArguments(process.argv));
+}

package/src/scripts/scaffold/data-mocks.ts

@@ -9,7 +9,11 @@ import {
   Union,
 } from "@typespec/compiler";
 import { $ } from "@typespec/compiler/experimental/typekit";
-import { parseCase } from "../../util/case.js";
+import { JsContext, Module } from "../../ctx.js";
+import { isUnspeakable, parseCase } from "../../util/case.js";
+
+import { module as dateTimeHelper } from "../../../generated-defs/helpers/datetime.js";
+import { KEYWORDS } from "../../util/keywords.js";
 
 /**
  * Generates a mock value for a TypeSpec Model.
@@ -19,13 +23,13 @@ import { parseCase } from "../../util/case.js";
  * @returns A JavaScript string representation of the mock data
  * @throws Error if a property cannot be mocked
  */
-function mockModel(type: Model): string {
+function mockModel(ctx: JsContext, module: Module, type: Model): string {
   if ($.array.is(type)) {
-    return mockArray(type);
+    return mockArray(ctx, module, type);
   }
 
   if ($.record.is(type)) {
-    return mockRecord(type);
+    return mockRecord(ctx, module, type);
   }
 
   const mock: string[][] = [];
@@ -37,18 +41,18 @@ function mockModel(type: Model): string {
   }
 
   for (const [name, prop] of properties) {
-    if (prop.optional) {
+    if (prop.optional || isUnspeakable(prop.name)) {
       continue;
     }
 
-    const propMock = mockType(prop.type);
+    const propMock = mockType(ctx, module, prop.type);
 
     if (!propMock) {
       throw new Error(`Could not mock property ${name} of type ${prop.type.kind}`);
     }
 
     const propName = parseCase(name).camelCase;
-    mock.push([propName, propMock]);
+    mock.push([KEYWORDS.has(propName) ? `_${propName}` : propName, propMock]);
   }
 
   // If all properties were optional, return an empty object
@@ -67,9 +71,9 @@ function mockModel(type: Model): string {
  * @param type - The TypeSpec array Model to mock
  * @returns A JavaScript string representation of the mock array
  */
-function mockArray(type: Model): string {
+function mockArray(ctx: JsContext, module: Module, type: Model): string {
   const elementType = $.array.getElementType(type);
-  const mockedType = mockType(elementType);
+  const mockedType = mockType(ctx, module, elementType);
 
   // If we can't mock the element type, return an empty array
   if (mockedType === undefined) {
@@ -85,9 +89,9 @@ function mockArray(type: Model): string {
  * @param type - The TypeSpec record Model to mock
  * @returns A JavaScript string representation of the mock record
  */
-function mockRecord(type: Model): string {
+function mockRecord(ctx: JsContext, module: Module, type: Model): string {
   const elementType = $.record.getElementType(type);
-  const mockedType = mockType(elementType);
+  const mockedType = mockType(ctx, module, elementType);
 
   if (mockedType === undefined) {
     return "{}";
@@ -104,8 +108,12 @@ function mockRecord(type: Model): string {
  * @param prop - The TypeSpec model property to mock
  * @returns A JavaScript string representation of the mocked property or undefined if it cannot be mocked
  */
-function mockModelProperty(prop: ModelProperty): string | undefined {
-  return mockType(prop.type);
+function mockModelProperty(
+  ctx: JsContext,
+  module: Module,
+  prop: ModelProperty,
+): string | undefined {
+  return mockType(ctx, module, prop.type);
 }
 
 /**
@@ -125,9 +133,9 @@ function mockLiteral(type: LiteralType): string {
  * @param type - The TypeSpec type to mock
  * @returns A JavaScript string representation of the mock data, or undefined if the type cannot be mocked
  */
-export function mockType(type: Type): string | undefined {
+export function mockType(ctx: JsContext, module: Module, type: Type): string | undefined {
   if ($.model.is(type)) {
-    return mockModel(type);
+    return mockModel(ctx, module, type);
   }
 
   if ($.literal.is(type)) {
@@ -135,15 +143,15 @@ export function mockType(type: Type): string | undefined {
   }
 
   if ($.modelProperty.is(type)) {
-    return mockModelProperty(type);
+    return mockModelProperty(ctx, module, type);
   }
 
   if ($.scalar.is(type)) {
-    return mockScalar(type);
+    return mockScalar(ctx, module, type);
   }
 
   if ($.union.is(type)) {
-    return mockUnion(type);
+    return mockUnion(ctx, module, type);
   }
 
   if (isVoidType(type)) {
@@ -159,12 +167,12 @@ export function mockType(type: Type): string | undefined {
  * @param union - The TypeSpec union to mock
  * @returns A JavaScript string representation of a mock for one variant, or undefined if no suitable variant is found
  */
-function mockUnion(union: Union): string | undefined {
+function mockUnion(ctx: JsContext, module: Module, union: Union): string | undefined {
   for (const variant of union.variants.values()) {
     if (isErrorType(variant.type)) {
       continue;
     }
-    return mockType(variant.type);
+    return mockType(ctx, module, variant.type);
   }
 
   return undefined;
@@ -177,12 +185,19 @@ function mockUnion(union: Union): string | undefined {
  * @param scalar - The TypeSpec scalar to mock
  * @returns A JavaScript string representation of a suitable mock value for the scalar type
  */
-function mockScalar(scalar: Scalar): string | undefined {
+function mockScalar(ctx: JsContext, module: Module, scalar: Scalar): string | undefined {
   if ($.scalar.isBoolean(scalar) || $.scalar.extendsBoolean(scalar)) {
     return JSON.stringify(true);
   }
   if ($.scalar.isNumeric(scalar) || $.scalar.extendsNumeric(scalar)) {
-    return JSON.stringify(42);
+    switch ((scalar as Scalar).name) {
+      case "integer":
+      case "int64":
+      case "uint64":
+        return "42n";
+      default:
+        return "42";
+    }
   }
 
   if ($.scalar.isUtcDateTime(scalar) || $.scalar.extendsUtcDateTime(scalar)) {
@@ -194,7 +209,12 @@ function mockScalar(scalar: Scalar): string | undefined {
   }
 
   if ($.scalar.isDuration(scalar) || $.scalar.extendsDuration(scalar)) {
-    return JSON.stringify("P1Y2M3DT4H5M6S");
+    module.imports.push({
+      from: dateTimeHelper,
+      binder: ["Duration"],
+    });
+
+    return 'Duration.parseISO8601("P1Y2M3DT4H5M6S")';
   }
 
   if ($.scalar.isOffsetDateTime(scalar) || $.scalar.extendsOffsetDateTime(scalar)) {

package/src/util/differentiate.ts

@@ -112,7 +112,7 @@ export interface Switch {
  */
 export interface Verbatim {
   kind: "verbatim";
-  body: Iterable<string>;
+  body: Iterable<string> | (() => Iterable<string>);
 }
 
 /**
@@ -380,7 +380,7 @@ export function differentiateTypes(
   const intrinsics = (categories.Intrinsic as (VoidType | NullType)[]) ?? [];
 
   if (literals.length + scalars.length + intrinsics.length === 0) {
-    return differentiateModelTypes(ctx, module, select(models, cases), renderPropertyName);
+    return differentiateModelTypes(ctx, module, select(models, cases), { renderPropertyName });
   } else {
     const branches: IfBranch[] = [];
 
@@ -505,7 +505,7 @@ export function differentiateTypes(
       branches,
       else:
         models.length > 0
-          ? differentiateModelTypes(ctx, module, select(models, cases), renderPropertyName)
+          ? differentiateModelTypes(ctx, module, select(models, cases), { renderPropertyName })
           : undefined,
     };
   }
@@ -589,6 +589,38 @@ function overlaps(range: IntegerRange, other: IntegerRange): boolean {
   return range[0] <= other[1] && range[1] >= other[0];
 }
 
+/**
+ * Optional paramters for model differentiation.
+ */
+interface DifferentiateModelOptions {
+  /**
+   * A function that converts a model property reference over the subject to a string.
+   *
+   * Default: `(prop) => prop.name`
+   */
+  renderPropertyName?: (prop: ModelProperty) => string;
+
+  /**
+   * A filter function that determines which properties to consider for differentiation.
+   *
+   * Default: `() => true`
+   */
+  filter?: (prop: ModelProperty) => boolean;
+
+  /**
+   * The default case to use if no other cases match.
+   *
+   * Default: undefined.
+   */
+  else?: CodeTree | undefined;
+}
+
+const DEFAULT_DIFFERENTIATE_OPTIONS = {
+  renderPropertyName: PROPERTY_ID,
+  filter: () => true,
+  else: undefined,
+} as const;
+
 /**
  * Differentiate a set of model types based on their properties. This function returns a CodeTree that will test an input
  * "subject" and determine which of the cases it matches, executing the corresponding code block.
@@ -602,8 +634,15 @@ export function differentiateModelTypes(
   ctx: JsContext,
   module: Module,
   models: Set<Model>,
-  renderPropertyName: (prop: ModelProperty) => string = PROPERTY_ID,
+  options?: DifferentiateModelOptions,
+): CodeTree;
+export function differentiateModelTypes(
+  ctx: JsContext,
+  module: Module,
+  models: Set<Model>,
+  _options: DifferentiateModelOptions = {},
 ): CodeTree {
+  const options = { ...DEFAULT_DIFFERENTIATE_OPTIONS, ..._options };
   // Horrible n^2 operation to get the unique properties of all models in the map, but hopefully n is small, so it should
   // be okay until you have a lot of models to differentiate.
 
@@ -623,14 +662,14 @@ export function differentiateModelTypes(
   for (const model of models) {
     const props = new Set<string>();
 
-    for (const prop of getAllProperties(model)) {
+    for (const prop of getAllProperties(model).filter(options.filter)) {
       // Don't consider optional properties for differentiation.
       if (prop.optional) continue;
 
       // Ignore properties that have no parseable name.
       if (isUnspeakable(prop.name)) continue;
 
-      const renderedPropName = renderPropertyName(prop) as RenderedPropertyName;
+      const renderedPropName = options.renderPropertyName(prop) as RenderedPropertyName;
 
       // CASE - literal value
 
@@ -716,7 +755,7 @@ export function differentiateModelTypes(
 
   const branches: IfBranch[] = [];
 
-  let defaultCase: Model | undefined = undefined;
+  let defaultCase: CodeTree | undefined = options.else;
 
   for (const [model, unique] of uniqueProps) {
     const literals = uniqueLiterals.get(model);
@@ -727,14 +766,11 @@ export function differentiateModelTypes(
           code: "undifferentiable-model",
           target: model,
         });
-        return {
-          kind: "result",
-          type: defaultCase,
-        };
+        return defaultCase;
       } else {
         // Allow a single default case. This covers more APIs that have a single model that is not differentiated by a
         // unique property, in which case we can make it the `else` case.
-        defaultCase = model;
+        defaultCase = { kind: "result", type: model };
         continue;
       }
     }
@@ -744,7 +780,7 @@ export function differentiateModelTypes(
       const firstUniqueLiteral = literals.values().next().value as RenderedPropertyName;
 
       const property = [...model.properties.values()].find(
-        (p) => (renderPropertyName(p) as RenderedPropertyName) === firstUniqueLiteral,
+        (p) => (options.renderPropertyName(p) as RenderedPropertyName) === firstUniqueLiteral,
       )!;
 
       branches.push({
@@ -752,7 +788,7 @@ export function differentiateModelTypes(
           kind: "binary-op",
           left: {
             kind: "binary-op",
-            left: { kind: "literal", value: renderPropertyName(property) },
+            left: { kind: "literal", value: options.renderPropertyName(property) },
             operator: "in",
             right: SUBJECT,
           },
@@ -774,7 +810,7 @@ export function differentiateModelTypes(
       const firstUniqueRange = ranges.values().next().value as RenderedPropertyName;
 
       const property = [...model.properties.values()].find(
-        (p) => renderPropertyName(p) === firstUniqueRange,
+        (p) => options.renderPropertyName(p) === firstUniqueRange,
       )!;
 
       const range = [...propertyRanges.get(firstUniqueRange)!.entries()].find(
@@ -786,7 +822,7 @@ export function differentiateModelTypes(
           kind: "binary-op",
           left: {
             kind: "binary-op",
-            left: { kind: "literal", value: renderPropertyName(property) },
+            left: { kind: "literal", value: options.renderPropertyName(property) },
             operator: "in",
             right: SUBJECT,
           },
@@ -817,12 +853,7 @@ export function differentiateModelTypes(
   return {
     kind: "if-chain",
     branches,
-    else: defaultCase
-      ? {
-          kind: "result",
-          type: defaultCase,
-        }
-      : undefined,
+    else: defaultCase,
   };
 }
 
@@ -903,7 +934,11 @@ export function* writeCodeTree(
       break;
     }
     case "verbatim":
-      yield* tree.body;
+      if (typeof tree.body === "function") {
+        yield* tree.body();
+      } else {
+        yield* tree.body;
+      }
       break;
     default:
       throw new UnreachableError("writeCodeTree for " + (tree satisfies never as CodeTree).kind, {