@modelprofile.com/flexharness 10.12.0 → 10.13.0

package/ts/index.ts

@@ -1,5 +1,6 @@
 export * from './classes.flexharness.js';
 export * from './classes.stores.js';
+export { FlexToolCatalog } from './classes.toolcatalog.js';
 export * from './errors.js';
 export * from './interfaces.js';
 export { normalizeJsonValue } from './utils.json.js';

package/ts/interfaces.ts

@@ -648,15 +648,179 @@ export interface IFlexToolProviderContext<TScope> extends IFlexSessionGeneration
   requestPermission(request: IFlexPermissionRequestInput): Promise<void>;
 }
 
-export interface IFlexToolHandle {
+export interface IFlexToolHandle<TScope = unknown> {
   tools: TFlexAgentToolSet;
+  /**
+   * Methods the model finds with `search_tools`, reads with `describe_tools` and calls with
+   * `execute`, instead of seeing each one as a tool on every step. Return the same object on
+   * every run: FlexHarness prepares a catalog once per object and treats it as immutable.
+   */
+  catalog?: IFlexToolCatalog<TScope>;
   close?(): Promise<void> | void;
 }
 
 export interface IFlexToolProvider<TScope> {
   provideTools(
     context: IFlexToolProviderContext<TScope>,
-  ): Promise<IFlexToolHandle | undefined> | IFlexToolHandle | undefined;
+  ): Promise<IFlexToolHandle<TScope> | undefined> | IFlexToolHandle<TScope> | undefined;
+}
+
+/** The names of the built-in catalog tools, reserved while a run has a catalog. */
+export const FLEX_TOOL_CATALOG_TOOL_NAMES = Object.freeze({
+  search: 'search_tools',
+  describe: 'describe_tools',
+  execute: 'execute',
+} as const);
+
+export const FLEX_TOOL_CATALOG_LIMITS = Object.freeze({
+  maxMethods: 4096,
+  maxTypes: 4096,
+  maxMethodPathCharacters: 160,
+  maxMethodPathSegments: 8,
+  maxIdentifierCharacters: 128,
+  maxSummaryCharacters: 120,
+  maxDescriptionBytes: 16 * 1024,
+  maxDeclarationBytes: 16 * 1024,
+  maxTags: 16,
+  maxTagCharacters: 48,
+  maxExamples: 4,
+  maxExampleBytes: 1024,
+  maxSchemaBytes: 64 * 1024,
+  defaultSearchResults: 10,
+  maxSearchResults: 50,
+  maxQueryCharacters: 512,
+  maxDescribeMethods: 16,
+  maxDescribeTypes: 32,
+  maxDescribeBytes: 64 * 1024,
+  maxParamIssues: 10,
+});
+
+export interface IFlexCatalogSearchInput {
+  /** Words to rank methods by. */
+  query?: string;
+  /** A dotted namespace to search in or, without `query`, to list. */
+  namespace?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface IFlexCatalogDescribeInput {
+  /** Dotted method paths. */
+  methods?: readonly string[];
+  /** Named types to declare again or for the first time. */
+  types?: readonly string[];
+}
+
+export interface IFlexCatalogDescribeResult {
+  /** TypeScript text, or a JSON object in `json-schema` mode. */
+  output: TJsonValue;
+  /** The named types the output declares. */
+  declaredTypes: string[];
+}
+
+/** One way `execute`'s params miss the method's schema. */
+export interface IFlexCatalogParamIssue {
+  /** Where, such as `params.lines[0].amount`. */
+  path: string;
+  expected: string;
+  /** The given value as compact JSON, or `missing`. */
+  got: string;
+}
+
+/** What `execute` reports to the model, as JSON, when it cannot call a method. */
+export type TFlexCatalogCallError =
+  | {
+      error: 'unknown_method';
+      method: string;
+      didYouMean: string[];
+      hint: string;
+    }
+  | {
+      error: 'invalid_params';
+      method: string;
+      issues: IFlexCatalogParamIssue[];
+      /** How many more issues were found than listed. */
+      more?: number;
+      /** The lookup that returns the method's declaration. */
+      see: string;
+    };
+
+export interface IFlexCatalogToolDefinition {
+  description: string;
+  /** The tool's input as JSON Schema. */
+  inputSchema: plugins.JSONSchema7;
+}
+
+/**
+ * A parameter or result schema: a plain JSON Schema object, or a zod, Standard Schema or AI SDK
+ * schema. `$ref`s to `#/$defs/<Name>` or `#/definitions/<Name>` that the schema does not define name
+ * a catalog type.
+ */
+export type TFlexCatalogSchema = { readonly [keyword: string]: unknown } | plugins.FlexibleSchema<unknown>;
+
+export interface IFlexCatalogRunContext<TScope = unknown> {
+  /** The dotted path the model called. */
+  readonly method: string;
+  /** The `execute` call's ID; pass it with permission requests. */
+  readonly toolCallId: string;
+  readonly abortSignal: AbortSignal;
+  /** The run's tool-provider context: scope, session, run and `requestPermission`. */
+  readonly provider: Readonly<IFlexToolProviderContext<TScope>>;
+}
+
+export interface IFlexCatalogMethod<TScope = unknown, TParams = any, TResult = unknown> {
+  /**
+   * The dotted path the model calls, such as `banking.listMovements`: up to 8 segments, each a
+   * JavaScript identifier of letters, digits and `_`.
+   */
+  method: string;
+  /** One line of at most 120 characters, shown in search results. */
+  summary: string;
+  /** The full description, shown with the declaration. */
+  description?: string;
+  /** More words `search_tools` matches. */
+  tags?: readonly string[];
+  /** Code shown as `@example` in the declaration. */
+  examples?: readonly string[];
+  /** The parameter object's schema; `execute` validates every call against it. */
+  inputSchema: TFlexCatalogSchema;
+  /** The result's schema, declared as the method's return type. */
+  outputSchema?: TFlexCatalogSchema;
+  /**
+   * Declaration text that replaces the generated one, such as a declaration built from TypeScript
+   * sources with their JSDoc: `function listMovements(params: …): Promise<…>;`, optionally after
+   * its JSDoc, with the last path segment as the function name.
+   */
+  declaration?: string;
+  /** Runs the method with validated parameters. */
+  run(
+    params: TParams,
+    context: IFlexCatalogRunContext<TScope>,
+  ): TResult | PromiseLike<TResult> | AsyncIterable<TResult>;
+}
+
+/** A named type that method declarations refer to; it needs a `declaration`, a `schema`, or both. */
+export interface IFlexCatalogType {
+  /** A JavaScript identifier such as `IMoney`. */
+  name: string;
+  description?: string;
+  /** Validates parameters that refer to this type, and generates its declaration. */
+  schema?: TFlexCatalogSchema;
+  /** Declaration text that replaces the generated one, such as `interface IMoney { … }`. */
+  declaration?: string;
+}
+
+export interface IFlexToolCatalog<TScope = unknown> {
+  methods: readonly IFlexCatalogMethod<TScope>[];
+  types?: readonly IFlexCatalogType[];
+}
+
+export interface IFlexToolCatalogOptions {
+  /**
+   * What `describe_tools` returns: `typescript` (default) declarations with named types shared
+   * across the session, or `json-schema` with each method's self-contained JSON Schema.
+   */
+  declarations?: 'typescript' | 'json-schema';
 }
 
 export interface IFlexResourceToolProviderResolverContext<TScope> extends IFlexSessionGeneration {
@@ -1419,6 +1583,7 @@ export interface IFlexHarnessOptions<TScope> {
   externalErrorProjector?: TFlexExternalErrorProjector;
   subagents?: IFlexSubagentDefinition[];
   builtInTools?: IFlexBuiltInToolsOptions;
+  toolCatalog?: IFlexToolCatalogOptions;
   slashCommands?: readonly TFlexSlashCommandRegistration<TScope>[];
   /** Maximum child depth (root is 0). Defaults to 6; configurable from 1 through 8. */
   maxSubagentDepth?: number;

package/ts/plugins.ts

@@ -6,6 +6,13 @@ import * as path from 'node:path';
 
 export { AsyncLocalStorage, crypto, fs, path };
 
+// third party scope
+import { asSchema, jsonSchema } from 'ai';
+import { Validator as JsonSchemaValidator } from '@cfworker/json-schema';
+
+export { asSchema, jsonSchema, JsonSchemaValidator };
+export type { FlexibleSchema, JSONSchema7, ModelMessage, Schema } from 'ai';
+
 // @push.rocks scope
 import {
   AgentEventStoreConflictError,

package/ts/utils.harnessoptions.ts

@@ -13,6 +13,7 @@ import type {
   IFlexSlashCommandHandlerRegistration,
   IFlexSlashCommandTemplateRegistration,
   IFlexSubagentDefinition,
+  IFlexToolCatalogOptions,
   TFlexSlashCommandRegistration,
 } from './interfaces.js';
 import {
@@ -156,6 +157,27 @@ export function normalizeSubagents(
   return Object.freeze(normalized);
 }
 
+export function normalizeToolCatalogOptions(
+  options: IFlexHarnessOptions<unknown>['toolCatalog'],
+): Readonly<Required<IFlexToolCatalogOptions>> {
+  if (options === undefined) return Object.freeze({ declarations: 'typescript' });
+  if (
+    !options
+    || typeof options !== 'object'
+    || Array.isArray(options)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(options))
+  ) {
+    throw new FlexHarnessValidationError('toolCatalog must be a plain object.');
+  }
+  const unsupported = Object.keys(options).find((key) => key !== 'declarations');
+  if (unsupported) throw new FlexHarnessValidationError(`toolCatalog does not support "${unsupported}".`);
+  const declarations = options.declarations ?? 'typescript';
+  if (declarations !== 'typescript' && declarations !== 'json-schema') {
+    throw new FlexHarnessValidationError('toolCatalog.declarations must be "typescript" or "json-schema".');
+  }
+  return Object.freeze({ declarations });
+}
+
 export function normalizeBuiltInTools(
   options: IFlexHarnessOptions<unknown>['builtInTools'],
 ): INormalizedBuiltInTools {

package/ts/utils.schemadeclarations.ts

@@ -0,0 +1,322 @@
+/**
+ * Renders JSON Schema as TypeScript declarations for the tool catalog. The output depends only on
+ * the schema, so the same schema always renders to the same bytes.
+ */
+
+export type TJsonSchemaNode = boolean | { [key: string]: unknown };
+
+export interface ISchemaDeclarationContext {
+  /** The named type a `$ref` denotes, or undefined to inline the referenced schema. */
+  namedType(ref: string): string | undefined;
+  /** The schema a local `$ref` points to. */
+  resolve(ref: string): TJsonSchemaNode | undefined;
+}
+
+export interface IRenderedDeclaration {
+  text: string;
+  /** Named types the text refers to, sorted. */
+  types: string[];
+}
+
+const identifierPattern = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const maxRenderDepth = 32;
+const maxInlineObjectCharacters = 100;
+const maxSafeInteger = Number.MAX_SAFE_INTEGER;
+
+export const isSchemaRecord = (value: unknown): value is { [key: string]: unknown } =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+export const isIdentifier = (value: string): boolean => identifierPattern.test(value);
+
+const literal = (value: unknown): string => {
+  if (typeof value === 'string') return JSON.stringify(value);
+  if (typeof value === 'number' && Number.isFinite(value)) return String(value);
+  if (typeof value === 'boolean' || value === null) return String(value);
+  return 'unknown';
+};
+
+/**
+ * Reports whether `character` occurs outside brackets, braces, parentheses, string literals and
+ * comments.
+ */
+const hasTopLevel = (text: string, character: string): boolean => {
+  let depth = 0;
+  let quote: string | undefined;
+  for (let index = 0; index < text.length; index++) {
+    const current = text[index];
+    if (quote) {
+      if (current === '\\') index++;
+      else if (current === quote) quote = undefined;
+      continue;
+    }
+    if (current === '/' && text[index + 1] === '*') {
+      const end = text.indexOf('*/', index + 2);
+      if (end === -1) return false;
+      index = end + 1;
+      continue;
+    }
+    if (current === '"' || current === "'") quote = current;
+    else if (current === '{' || current === '[' || current === '(' || current === '<') depth++;
+    else if (current === '}' || current === ']' || current === ')' || current === '>') depth--;
+    else if (depth === 0 && current === character) return true;
+  }
+  return false;
+};
+
+const union = (parts: string[]): string => {
+  const unique = [...new Set(parts)];
+  if (unique.includes('unknown')) return 'unknown';
+  const withoutNever = unique.length > 1 ? unique.filter((part) => part !== 'never') : unique;
+  return withoutNever.join(' | ');
+};
+
+const intersection = (parts: string[]): string => {
+  const unique = [...new Set(parts)].filter((part) => part !== 'unknown');
+  if (unique.length === 0) return 'unknown';
+  return unique.map((part) => hasTopLevel(part, '|') ? `(${part})` : part).join(' & ');
+};
+
+const arrayOf = (element: string): string =>
+  hasTopLevel(element, '|') || hasTopLevel(element, '&') ? `(${element})[]` : `${element}[]`;
+
+const propertyKey = (name: string): string => isIdentifier(name) ? name : JSON.stringify(name);
+
+/** A JSDoc block at `indent`; a short single line stays on one line. */
+export const docBlock = (text: string, indent: string): string => {
+  const lines = text.replace(/\*\//g, '*\\/').split('\n').map((line) => line.trimEnd());
+  if (lines.length === 1 && indent.length + lines[0].length <= 100) return `${indent}/** ${lines[0]} */\n`;
+  return `${indent}/**\n${lines.map((line) => line ? `${indent} * ${line}` : `${indent} *`).join('\n')}\n${indent} */\n`;
+};
+
+export const countOf = (count: number, unit: string): string => `${count} ${unit}${count === 1 ? '' : 's'}`;
+
+/** Constraints a TypeScript type cannot state, in a short readable form. */
+const constraintsOf = (schema: { [key: string]: unknown }): string[] => {
+  const constraints: string[] = [];
+  const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+  if (types.includes('integer')) constraints.push('integer');
+  if (typeof schema.format === 'string') constraints.push(`format ${schema.format}`);
+  const bound = (value: unknown): value is number =>
+    typeof value === 'number' && Number.isFinite(value) && Math.abs(value) !== maxSafeInteger;
+  if (bound(schema.exclusiveMinimum)) constraints.push(`> ${schema.exclusiveMinimum}`);
+  else if (bound(schema.minimum)) constraints.push(`${schema.exclusiveMinimum === true ? '>' : '>='} ${schema.minimum}`);
+  if (bound(schema.exclusiveMaximum)) constraints.push(`< ${schema.exclusiveMaximum}`);
+  else if (bound(schema.maximum)) constraints.push(`${schema.exclusiveMaximum === true ? '<' : '<='} ${schema.maximum}`);
+  if (bound(schema.multipleOf)) constraints.push(`multiple of ${schema.multipleOf}`);
+  const range = (min: unknown, max: unknown, unit: string): void => {
+    const hasMin = bound(min) && min > 0;
+    const hasMax = bound(max);
+    if (hasMin && hasMax) constraints.push(min === max ? countOf(min, unit) : `${min}-${countOf(max, unit)}`);
+    else if (hasMin) constraints.push(`at least ${countOf(min, unit)}`);
+    else if (hasMax) constraints.push(`at most ${countOf(max, unit)}`);
+  };
+  range(schema.minLength, schema.maxLength, 'character');
+  range(schema.minItems, schema.maxItems, 'item');
+  if (schema.uniqueItems === true) constraints.push('unique items');
+  if (typeof schema.pattern === 'string') constraints.push(`pattern /${schema.pattern}/`);
+  if (schema.default !== undefined) {
+    const value = JSON.stringify(schema.default);
+    if (value !== undefined && value.length <= 60) constraints.push(`default ${value}`);
+  }
+  if (schema.deprecated === true) constraints.push('deprecated');
+  return constraints;
+};
+
+/** The documentation of a property: its description and the constraints its type cannot state. */
+export const schemaDoc = (schema: TJsonSchemaNode, description?: string): string | undefined => {
+  if (!isSchemaRecord(schema)) return description?.trim() || undefined;
+  const text = (description ?? (typeof schema.description === 'string' ? schema.description : '')).trim();
+  const constraints = constraintsOf(schema);
+  if (constraints.length === 0) return text || undefined;
+  return text ? `${text} (${constraints.join(', ')})` : constraints.join(', ');
+};
+
+export class SchemaDeclarationWriter {
+  private readonly used = new Set<string>();
+  private readonly inlining = new Set<string>();
+
+  constructor(private readonly context: ISchemaDeclarationContext) {}
+
+  public get usedTypes(): string[] {
+    return [...this.used].sort();
+  }
+
+  /** The TypeScript type of `schema`, with continuation lines indented relative to `indent`. */
+  public type(schema: TJsonSchemaNode, indent = '', depth = 0, omitMemberDocs = false): string {
+    if (depth > maxRenderDepth) return 'unknown';
+    if (schema === true) return 'unknown';
+    if (schema === false) return 'never';
+    if (!isSchemaRecord(schema)) return 'unknown';
+    const base = this.baseType(schema, indent, depth, omitMemberDocs);
+    return schema.nullable === true ? union([base, 'null']) : base;
+  }
+
+  /** The members of an object schema; undefined when the schema is not a plain object type. */
+  public objectMembers(
+    schema: TJsonSchemaNode,
+  ): Array<{ name: string; doc?: string }> | undefined {
+    if (!isSchemaRecord(schema) || !this.isPlainObject(schema)) return undefined;
+    const properties = isSchemaRecord(schema.properties) ? schema.properties : {};
+    return Object.entries(properties).map(([name, property]) => {
+      const doc = schemaDoc(property as TJsonSchemaNode);
+      return { name, ...(doc === undefined ? {} : { doc }) };
+    });
+  }
+
+  /** Whether an object schema requires none of its properties. */
+  public hasNoRequiredProperties(schema: TJsonSchemaNode): boolean {
+    return isSchemaRecord(schema)
+      && this.isPlainObject(schema)
+      && !(Array.isArray(schema.required) && schema.required.length > 0);
+  }
+
+  /** `interface Name { … }` for a plain object schema, otherwise `type Name = …;`. */
+  public namedDeclaration(name: string, schema: TJsonSchemaNode, description?: string): string {
+    const doc = isSchemaRecord(schema)
+      ? (description ?? (typeof schema.description === 'string' ? schema.description : undefined))?.trim()
+      : description?.trim();
+    const prefix = doc ? docBlock(doc, '') : '';
+    if (isSchemaRecord(schema) && this.isPlainObject(schema) && schema.nullable !== true) {
+      return `${prefix}interface ${name} ${this.objectType(schema, '', 0, false)}`;
+    }
+    return `${prefix}type ${name} = ${this.type(schema, '', 0)};`;
+  }
+
+  private isPlainObject(schema: { [key: string]: unknown }): boolean {
+    if (schema.$ref !== undefined || 'const' in schema || schema.enum !== undefined) return false;
+    if (schema.anyOf !== undefined || schema.oneOf !== undefined || schema.allOf !== undefined) return false;
+    if (schema.type === 'object') return true;
+    return schema.type === undefined && isSchemaRecord(schema.properties);
+  }
+
+  private baseType(
+    schema: { [key: string]: unknown },
+    indent: string,
+    depth: number,
+    omitMemberDocs: boolean,
+  ): string {
+    if (typeof schema.$ref === 'string') return this.reference(schema.$ref, indent, depth);
+    if ('const' in schema) return literal(schema.const);
+    if (Array.isArray(schema.enum)) return schema.enum.length ? union(schema.enum.map(literal)) : 'never';
+    const alternatives = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : undefined;
+    if (alternatives?.length) {
+      return union(alternatives.map((alternative) => this.type(alternative as TJsonSchemaNode, indent, depth + 1)));
+    }
+    if (Array.isArray(schema.allOf) && schema.allOf.length) {
+      const own = { ...schema };
+      delete own.allOf;
+      const hasOwnShape = own.type !== undefined || own.properties !== undefined;
+      return intersection([
+        ...schema.allOf.map((part) => this.type(part as TJsonSchemaNode, indent, depth + 1)),
+        ...(hasOwnShape ? [this.type(own, indent, depth + 1)] : []),
+      ]);
+    }
+    const types = Array.isArray(schema.type)
+      ? schema.type.filter((type): type is string => typeof type === 'string')
+      : typeof schema.type === 'string'
+        ? [schema.type]
+        : this.inferredTypes(schema);
+    if (types.length === 0) return 'unknown';
+    return union(types.map((type) => {
+      switch (type) {
+        case 'string': return 'string';
+        case 'number':
+        case 'integer': return 'number';
+        case 'boolean': return 'boolean';
+        case 'null': return 'null';
+        case 'array': return this.arrayType(schema, indent, depth);
+        case 'object': return this.objectType(schema, indent, depth, omitMemberDocs);
+        default: return 'unknown';
+      }
+    }));
+  }
+
+  private inferredTypes(schema: { [key: string]: unknown }): string[] {
+    if (
+      schema.properties !== undefined
+      || schema.additionalProperties !== undefined
+      || schema.patternProperties !== undefined
+      || schema.required !== undefined
+    ) return ['object'];
+    if (schema.items !== undefined || schema.prefixItems !== undefined) return ['array'];
+    return [];
+  }
+
+  private reference(ref: string, indent: string, depth: number): string {
+    const name = this.context.namedType(ref);
+    if (name) {
+      this.used.add(name);
+      return name;
+    }
+    const target = this.context.resolve(ref);
+    if (target === undefined || this.inlining.has(ref)) return 'unknown';
+    this.inlining.add(ref);
+    try {
+      return this.type(target, indent, depth + 1);
+    } finally {
+      this.inlining.delete(ref);
+    }
+  }
+
+  private arrayType(schema: { [key: string]: unknown }, indent: string, depth: number): string {
+    const tuple = Array.isArray(schema.prefixItems)
+      ? schema.prefixItems
+      : Array.isArray(schema.items) ? schema.items : undefined;
+    if (tuple) {
+      const rest = Array.isArray(schema.prefixItems) ? schema.items : schema.additionalItems;
+      const members = tuple.map((item) => this.type(item as TJsonSchemaNode, indent, depth + 1));
+      if (rest !== undefined && rest !== false) {
+        members.push(`...${arrayOf(this.type(rest as TJsonSchemaNode, indent, depth + 1))}`);
+      }
+      return `[${members.join(', ')}]`;
+    }
+    if (schema.items === undefined) return 'unknown[]';
+    return arrayOf(this.type(schema.items as TJsonSchemaNode, indent, depth + 1));
+  }
+
+  private objectType(
+    schema: { [key: string]: unknown },
+    indent: string,
+    depth: number,
+    omitMemberDocs: boolean,
+  ): string {
+    const memberIndent = `${indent}  `;
+    const properties = isSchemaRecord(schema.properties) ? schema.properties : {};
+    const required = new Set(Array.isArray(schema.required)
+      ? schema.required.filter((name): name is string => typeof name === 'string')
+      : []);
+    const members: Array<{ doc?: string; text: string }> = [];
+    for (const [name, property] of Object.entries(properties)) {
+      const type = this.type(property as TJsonSchemaNode, memberIndent, depth + 1);
+      const doc = omitMemberDocs ? undefined : schemaDoc(property as TJsonSchemaNode);
+      members.push({
+        ...(doc === undefined ? {} : { doc }),
+        text: `${propertyKey(name)}${required.has(name) ? '' : '?'}: ${type}`,
+      });
+    }
+    const indexTypes: string[] = [];
+    if (isSchemaRecord(schema.patternProperties)) {
+      for (const property of Object.values(schema.patternProperties)) {
+        indexTypes.push(this.type(property as TJsonSchemaNode, memberIndent, depth + 1));
+      }
+    }
+    if (isSchemaRecord(schema.additionalProperties)) {
+      indexTypes.push(this.type(schema.additionalProperties, memberIndent, depth + 1));
+    } else if (schema.additionalProperties === true && members.length > 0) {
+      indexTypes.push('unknown');
+    }
+    if (indexTypes.length) members.push({ text: `[key: string]: ${union(indexTypes)}` });
+    if (members.length === 0) return schema.additionalProperties === false ? '{}' : 'Record<string, unknown>';
+    if (members.every((member) => member.doc === undefined && !member.text.includes('\n'))) {
+      const inline = `{ ${members.map((member) => member.text).join('; ')} }`;
+      if (inline.length <= maxInlineObjectCharacters) return inline;
+    }
+    const lines = members.map((member) =>
+      `${member.doc === undefined ? '' : docBlock(member.doc, memberIndent)}${memberIndent}${member.text};`);
+    return `{\n${lines.join('\n')}\n${indent}}`;
+  }
+}
+
+/** Indents every non-empty line of `text`. */
+export const indentLines = (text: string, indent: string): string =>
+  text.split('\n').map((line) => line ? `${indent}${line}` : line).join('\n');