@bsb/base 9.0.4 → 9.1.0

package/lib/scripts/generate-client-types.js

@@ -1,148 +1,17 @@
-"use strict";
 /**
  * BSB Virtual Client Generator
  *
- * Generates TypeScript virtual client files from exported schema JSON files.
- * These client files provide typed wrappers around the event bus, enabling
- * type-safe cross-plugin communication without direct source imports.
- *
- * Schema sources:
- *   1. Local build: lib/schemas/*.json (from this project's export-schemas)
- *   2. Remote install: src/.bsb/schemas/*.json (from bsb client install)
- *
- * Output:
- *   Writes TypeScript files to src/.bsb/clients/{plugin-name}.ts
- *
- * Generated clients use bsb.* builders to define BSBType schemas (same as
- * real plugins), then export inferred TypeScript types from those schemas.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateClientTypes = main;
-const fs = require("fs");
-const path = require("path");
-/**
- * Convert JSON Schema to a bsb.* builder call string.
- * Reconstructs the BSBType builder expression from exported JSON Schema.
+ * Generates TypeScript virtual client files from exported AnyVali schema documents.
  */
-function jsonSchemaToBsbCode(schema) {
-    // Handle enum
-    if (schema.enum) {
-        const values = schema.enum.map((v) => JSON.stringify(v)).join(', ');
-        const desc = schema.description ? `, ${JSON.stringify(schema.description)}` : '';
-        return `bsb.enum([${values}]${desc})`;
-    }
-    // Handle oneOf (union types / void)
-    if (schema.oneOf && Array.isArray(schema.oneOf)) {
-        if (schema.oneOf.length === 0) {
-            // void or unknown
-            if (schema.description === 'void') {
-                return 'bsb.void()';
-            }
-            return `bsb.unknown(${schema.description ? JSON.stringify(schema.description) : ''})`;
-        }
-        const types = schema.oneOf.map((s) => jsonSchemaToBsbCode(s)).join(', ');
-        const desc = schema.description ? `, ${JSON.stringify(schema.description)}` : '';
-        return `bsb.union([${types}]${desc})`;
-    }
-    // Handle array type (can be string or string[])
-    const types = Array.isArray(schema.type) ? schema.type : [schema.type];
-    const type = types[0];
-    switch (type) {
-        case 'string': {
-            // Check format for specialized types
-            if (schema.format === 'uuid') {
-                return `bsb.uuid(${schema.description ? JSON.stringify(schema.description) : ''})`;
-            }
-            if (schema.format === 'datetime') {
-                return `bsb.datetime(${schema.description ? JSON.stringify(schema.description) : ''})`;
-            }
-            if (schema.format === 'email') {
-                return `bsb.email(${schema.description ? JSON.stringify(schema.description) : ''})`;
-            }
-            if (schema.format === 'uri' || schema.format === 'url') {
-                return `bsb.uri(${schema.description ? JSON.stringify(schema.description) : ''})`;
-            }
-            // Generic string
-            const opts = [];
-            if (schema.minLength !== undefined)
-                opts.push(`min: ${schema.minLength}`);
-            if (schema.maxLength !== undefined)
-                opts.push(`max: ${schema.maxLength}`);
-            if (schema.pattern)
-                opts.push(`pattern: ${JSON.stringify(schema.pattern)}`);
-            if (schema.description)
-                opts.push(`description: ${JSON.stringify(schema.description)}`);
-            if (opts.length === 0)
-                return 'bsb.string()';
-            return `bsb.string({ ${opts.join(', ')} })`;
-        }
-        case 'number':
-        case 'integer': {
-            const format = schema.format;
-            const opts = [];
-            if (schema.description)
-                opts.push(`description: ${JSON.stringify(schema.description)}`);
-            const optsStr = opts.length > 0 ? `{ ${opts.join(', ')} }` : '';
-            if (format === 'int32')
-                return `bsb.int32(${optsStr ? optsStr : ''})`;
-            if (format === 'int64')
-                return `bsb.int64(${optsStr ? optsStr : ''})`;
-            if (format === 'float')
-                return `bsb.float(${optsStr ? optsStr : ''})`;
-            // Default: number (double)
-            return `bsb.number(${optsStr ? optsStr : ''})`;
-        }
-        case 'boolean':
-            return `bsb.boolean(${schema.description ? JSON.stringify(schema.description) : ''})`;
-        case 'array': {
-            const itemsCode = schema.items ? jsonSchemaToBsbCode(schema.items) : 'bsb.unknown()';
-            const opts = [];
-            if (schema.minItems !== undefined)
-                opts.push(`min: ${schema.minItems}`);
-            if (schema.maxItems !== undefined)
-                opts.push(`max: ${schema.maxItems}`);
-            if (schema.description)
-                opts.push(`description: ${JSON.stringify(schema.description)}`);
-            if (opts.length === 0)
-                return `bsb.array(${itemsCode})`;
-            return `bsb.array(${itemsCode}, { ${opts.join(', ')} })`;
-        }
-        case 'object': {
-            if (!schema.properties || Object.keys(schema.properties).length === 0) {
-                return `bsb.object({}, ${schema.description ? JSON.stringify(schema.description) : "''"})`;
-            }
-            const required = schema.required || [];
-            const propLines = [];
-            for (const [key, propSchema] of Object.entries(schema.properties)) {
-                const propCode = jsonSchemaToBsbCode(propSchema);
-                const isOptional = !required.includes(key);
-                if (isOptional) {
-                    propLines.push(`    ${key}: optional(${propCode})`);
-                }
-                else {
-                    propLines.push(`    ${key}: ${propCode}`);
-                }
-            }
-            const desc = schema.description ? `, ${JSON.stringify(schema.description)}` : '';
-            return `bsb.object({\n${propLines.join(',\n')}\n  }${desc})`;
-        }
-        default:
-            return 'bsb.unknown()';
-    }
+import * as fs from 'fs';
+import * as path from 'path';
+import { isMainModule } from '../base/module-runtime.js';
+function anyValiDocumentToCode(document) {
+    return `av.importSchema(${JSON.stringify(document)} as av.AnyValiDocument)`;
 }
-/**
- * Convert event name to camelCase method name.
- * e.g., 'todo.create' → 'todoCreate', 'todo-created' → 'todoCreated'
- */
 function eventNameToMethodName(eventName) {
-    return eventName
-        .replace(/[.-](\w)/g, (_, c) => c.toUpperCase());
+    return eventName.replace(/[.-](\w)/g, (_, c) => c.toUpperCase());
 }
-/**
- * Convert plugin key/ID to PascalCase client class name.
- * Strip 'service-' prefix, remove non-alphanumeric chars, PascalCase, append 'Client'.
- * e.g., 'service-todo' → 'TodoClient', 'bsb-registry' → 'BsbRegistryClient'
- */
 function pluginNameToClassName(pluginId) {
     let name = pluginId;
     if (name.startsWith('service-')) {
@@ -151,58 +20,41 @@ function pluginNameToClassName(pluginId) {
     const pascal = name
         .replace(/[^a-zA-Z0-9-]/g, '')
         .split('-')
-        .filter(part => part.length > 0)
-        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .filter((part) => part.length > 0)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
         .join('');
-    return pascal + 'Client';
+    return `${pascal}Client`;
 }
-/**
- * Generate a const name from event name and role.
- * e.g., 'todo.create' + 'Input' → '_todoCreateInput'
- */
 function eventNameToConstName(eventName, suffix) {
-    const camel = eventNameToMethodName(eventName);
-    return '_' + camel + suffix;
+    return `_${eventNameToMethodName(eventName)}${suffix}`;
 }
-/**
- * Flip mapping for client method generation.
- * Service's onReturnableEvents → client emits returnable events, etc.
- */
 const FLIP_MAP = {
-    'emitEvents': 'onEvents',
-    'onEvents': 'emitEvents',
-    'emitReturnableEvents': 'onReturnableEvents',
-    'onReturnableEvents': 'emitReturnableEvents',
-    'emitBroadcast': 'onBroadcast',
-    'onBroadcast': 'emitBroadcast',
+    emitEvents: 'onEvents',
+    onEvents: 'emitEvents',
+    emitReturnableEvents: 'onReturnableEvents',
+    onReturnableEvents: 'emitReturnableEvents',
+    emitBroadcast: 'onBroadcast',
+    onBroadcast: 'emitBroadcast',
 };
-/**
- * Generate virtual client TypeScript file from exported schema.
- * @param pluginId The plugin key/ID (from schema filename), used for class naming
- */
 function generateVirtualClient(schemaExport, importBase, pluginId) {
     const lines = [];
     const className = pluginNameToClassName(pluginId);
-    // File header
-    lines.push(`/**`);
+    lines.push('/**');
     lines.push(` * Auto-generated BSB virtual client for ${schemaExport.pluginName}`);
-    lines.push(` * DO NOT EDIT - Regenerated on every build`);
+    lines.push(' * DO NOT EDIT - Regenerated on every build');
     lines.push(` * @version ${schemaExport.version}`);
-    lines.push(` */`);
-    // Import paths differ between @bsb/base (external) and self-build (relative)
+    lines.push(' */');
+    lines.push('import * as av from "@anyvali/js";');
     if (importBase === '@bsb/base') {
-        lines.push(`import { ServiceClient, BSBService, bsb, optional } from "@bsb/base";`);
-        lines.push(`import { createReturnableEvent, createFireAndForgetEvent, createBroadcastEvent, createEventSchemas } from "@bsb/base";`);
-        lines.push(`import type { Observable, BSBServiceClientDefinition, EventInputType, EventOutputType } from "@bsb/base";`);
+        lines.push('import { ServiceClient, BSBService, createReturnableEvent, createFireAndForgetEvent, createBroadcastEvent, createEventSchemas } from "@bsb/base";');
+        lines.push('import type { Observable, BSBServiceClientDefinition, EventInputType, EventOutputType } from "@bsb/base";');
     }
     else {
-        // Self-build: src/.bsb/clients/ → ../../index for the main barrel
-        lines.push(`import { ServiceClient, BSBService, bsb, optional } from "../../index";`);
-        lines.push(`import { createReturnableEvent, createFireAndForgetEvent, createBroadcastEvent, createEventSchemas } from "../../interfaces/schema-events";`);
-        lines.push(`import type { Observable, BSBServiceClientDefinition, EventInputType, EventOutputType } from "../../index";`);
+        lines.push('import { ServiceClient, BSBService } from "../../index.js";');
+        lines.push('import { createReturnableEvent, createFireAndForgetEvent, createBroadcastEvent, createEventSchemas } from "../../interfaces/schema-events.js";');
+        lines.push('import type { Observable, BSBServiceClientDefinition, EventInputType, EventOutputType } from "../../index.js";');
     }
     lines.push('');
-    // Group events by category
     const categorizedEvents = {
         emitEvents: [],
         onEvents: [],
@@ -212,28 +64,22 @@ function generateVirtualClient(schemaExport, importBase, pluginId) {
         onBroadcast: [],
     };
     for (const [eventName, eventDef] of Object.entries(schemaExport.events)) {
-        const def = eventDef;
-        if (categorizedEvents[def.category]) {
-            categorizedEvents[def.category].push({ name: eventName, def });
+        if (categorizedEvents[eventDef.category]) {
+            categorizedEvents[eventDef.category].push({ name: eventName, def: eventDef });
         }
     }
-    // --- Generate BSBType schema consts for each event's input/output ---
     const constsDone = new Set();
     for (const events of Object.values(categorizedEvents)) {
         for (const { name, def } of events) {
-            // Input const
             const inputConst = eventNameToConstName(name, 'Schema');
             if (!constsDone.has(inputConst)) {
-                const bsbCode = jsonSchemaToBsbCode(def.inputSchema);
-                lines.push(`const ${inputConst} = ${bsbCode};`);
+                lines.push(`const ${inputConst} = ${anyValiDocumentToCode(def.inputSchema)};`);
                 constsDone.add(inputConst);
             }
-            // Output const (only for returnable events)
             if (def.type === 'returnable' && def.outputSchema) {
                 const outputConst = eventNameToConstName(name, 'OutputSchema');
                 if (!constsDone.has(outputConst)) {
-                    const bsbCode = jsonSchemaToBsbCode(def.outputSchema);
-                    lines.push(`const ${outputConst} = ${bsbCode};`);
+                    lines.push(`const ${outputConst} = ${anyValiDocumentToCode(def.outputSchema)};`);
                     constsDone.add(outputConst);
                 }
             }
@@ -242,58 +88,53 @@ function generateVirtualClient(schemaExport, importBase, pluginId) {
     if (constsDone.size > 0) {
         lines.push('');
     }
-    // --- Generate Event Schemas using createEventSchemas ---
-    lines.push(`// --- Event Schemas (typed, follows ServiceClientEventSchemas flip) ---`);
-    lines.push(`const _EventSchemas = createEventSchemas({`);
+    lines.push('const _EventSchemas = createEventSchemas({');
     for (const [category, events] of Object.entries(categorizedEvents)) {
         if (events.length === 0)
             continue;
         lines.push(`  ${category}: {`);
         for (const { name, def } of events) {
             const inputConst = eventNameToConstName(name, 'Schema');
-            const desc = def.description ? JSON.stringify(def.description) : undefined;
+            const descriptionArg = def.description !== undefined ? `, ${JSON.stringify(def.description)}` : '';
             if (def.type === 'returnable') {
                 const outputConst = eventNameToConstName(name, 'OutputSchema');
-                const descArg = desc ? `, ${desc}` : '';
-                const timeoutArg = def.defaultTimeout !== undefined ? `, ${def.defaultTimeout}` : '';
-                // If we have timeout but no desc, we need desc placeholder
-                if (def.defaultTimeout !== undefined && !desc) {
-                    lines.push(`    '${name}': createReturnableEvent(${inputConst}, ${outputConst}, undefined, ${def.defaultTimeout}),`);
+                if (def.defaultTimeout !== undefined) {
+                    if (def.description !== undefined) {
+                        lines.push(`    '${name}': createReturnableEvent(${inputConst}, ${outputConst}, ${JSON.stringify(def.description)}, ${def.defaultTimeout}),`);
+                    }
+                    else {
+                        lines.push(`    '${name}': createReturnableEvent(${inputConst}, ${outputConst}, undefined, ${def.defaultTimeout}),`);
+                    }
                 }
                 else {
-                    lines.push(`    '${name}': createReturnableEvent(${inputConst}, ${outputConst}${descArg}${timeoutArg}),`);
+                    lines.push(`    '${name}': createReturnableEvent(${inputConst}, ${outputConst}${descriptionArg}),`);
                 }
             }
             else if (def.type === 'broadcast') {
-                const descArg = desc ? `, ${desc}` : '';
-                lines.push(`    '${name}': createBroadcastEvent(${inputConst}${descArg}),`);
+                lines.push(`    '${name}': createBroadcastEvent(${inputConst}${descriptionArg}),`);
             }
             else {
-                const descArg = desc ? `, ${desc}` : '';
-                lines.push(`    '${name}': createFireAndForgetEvent(${inputConst}${descArg}),`);
+                lines.push(`    '${name}': createFireAndForgetEvent(${inputConst}${descriptionArg}),`);
             }
         }
-        lines.push(`  },`);
+        lines.push('  },');
     }
-    lines.push(`});`);
+    lines.push('});');
     lines.push('');
-    // --- Export inferred types ---
-    lines.push(`// --- Exported Types (inferred from BSBType schemas) ---`);
+    lines.push('// These resolve to broad types because the source of truth is a portable AnyVali document.');
     const typesDone = new Set();
     for (const events of Object.values(categorizedEvents)) {
         for (const { name, def } of events) {
             const camel = eventNameToMethodName(name);
             const typeName = camel.charAt(0).toUpperCase() + camel.slice(1);
-            // Input type
-            const inputTypeName = typeName + 'Input';
+            const inputTypeName = `${typeName}Input`;
             if (!typesDone.has(inputTypeName)) {
                 const inputConst = eventNameToConstName(name, 'Schema');
                 lines.push(`export type ${inputTypeName} = EventInputType<{ input: typeof ${inputConst} }>;`);
                 typesDone.add(inputTypeName);
             }
-            // Output type (returnable only)
             if (def.type === 'returnable' && def.outputSchema) {
-                const outputTypeName = typeName + 'Output';
+                const outputTypeName = `${typeName}Output`;
                 if (!typesDone.has(outputTypeName)) {
                     const outputConst = eventNameToConstName(name, 'OutputSchema');
                     lines.push(`export type ${outputTypeName} = EventOutputType<{ output: typeof ${outputConst} }>;`);
@@ -303,97 +144,83 @@ function generateVirtualClient(schemaExport, importBase, pluginId) {
         }
     }
     lines.push('');
-    // --- Internal Plugin Reference ---
-    lines.push(`// --- Internal: Plugin reference for ServiceClient wiring ---`);
-    lines.push(`const _PLUGIN_CLIENT: BSBServiceClientDefinition = {`);
+    lines.push('const _PLUGIN_CLIENT: BSBServiceClientDefinition = {');
     lines.push(`  name: "${pluginId}",`);
-    lines.push(`};`);
+    lines.push('};');
     lines.push('');
-    lines.push(`class _PluginRef {`);
-    lines.push(`  static PLUGIN_CLIENT = _PLUGIN_CLIENT;`);
-    lines.push(`}`);
+    lines.push('class _PluginRef {');
+    lines.push('  static PLUGIN_CLIENT = _PLUGIN_CLIENT;');
+    lines.push('}');
     lines.push('');
-    // --- Exported Client Class ---
-    lines.push(`// --- Exported Client ---`);
     lines.push(`export default class ${className} extends ServiceClient<any, typeof _EventSchemas, typeof _PluginRef> {`);
-    lines.push(`  constructor(context: BSBService) {`);
-    lines.push(`    super(_PluginRef, context);`);
-    lines.push(`  }`);
-    // Generate methods for each event (flip categories for client perspective)
+    lines.push('  constructor(context: BSBService) {');
+    lines.push('    super(_PluginRef, context);');
+    lines.push('  }');
     for (const [category, events] of Object.entries(categorizedEvents)) {
-        if (events.length === 0)
-            continue;
         const clientCategory = FLIP_MAP[category];
         if (!clientCategory)
             continue;
         for (const { name, def } of events) {
             const methodName = eventNameToMethodName(name);
-            const camel = eventNameToMethodName(name);
-            const typeName = camel.charAt(0).toUpperCase() + camel.slice(1);
-            const inputTypeName = typeName + 'Input';
+            const typeName = methodName.charAt(0).toUpperCase() + methodName.slice(1);
+            const inputTypeName = `${typeName}Input`;
             const description = def.description || name;
             lines.push('');
-            switch (clientCategory) {
-                case 'emitEvents': {
-                    lines.push(`  /** ${description} */`);
-                    lines.push(`  async ${methodName}(obs: Observable, input: ${inputTypeName}): Promise<void> {`);
-                    lines.push(`    await this.events.emitEvent("${name}", obs, input);`);
-                    lines.push(`  }`);
-                    break;
-                }
-                case 'emitReturnableEvents': {
-                    const outputTypeName = typeName + 'Output';
-                    const timeout = def.defaultTimeout ?? 5;
-                    lines.push(`  /** ${description} (default timeout: ${timeout}s) */`);
-                    lines.push(`  async ${methodName}(obs: Observable, input: ${inputTypeName}, timeout: number = ${timeout}): Promise<${outputTypeName}> {`);
-                    lines.push(`    return this.events.emitEventAndReturn("${name}", obs, input, timeout);`);
-                    lines.push(`  }`);
-                    break;
-                }
-                case 'emitBroadcast': {
-                    const emitMethodName = 'emit' + methodName.charAt(0).toUpperCase() + methodName.slice(1);
-                    lines.push(`  /** ${description} */`);
-                    lines.push(`  async ${emitMethodName}(obs: Observable, input: ${inputTypeName}): Promise<void> {`);
-                    lines.push(`    await this.events.emitBroadcast("${name}", obs, input);`);
-                    lines.push(`  }`);
-                    break;
-                }
-                case 'onEvents': {
-                    const onMethodName = 'on' + methodName.charAt(0).toUpperCase() + methodName.slice(1);
-                    lines.push(`  /** ${description} */`);
-                    lines.push(`  async ${onMethodName}(obs: Observable, handler: (handlerObs: Observable, input: ${inputTypeName}) => Promise<void>): Promise<void> {`);
-                    lines.push(`    await this.events.onEvent("${name}", obs, handler);`);
-                    lines.push(`  }`);
-                    break;
-                }
-                case 'onReturnableEvents': {
-                    const outputTypeName = typeName + 'Output';
-                    const onMethodName = 'on' + methodName.charAt(0).toUpperCase() + methodName.slice(1);
-                    lines.push(`  /** ${description} */`);
-                    lines.push(`  async ${onMethodName}(obs: Observable, handler: (handlerObs: Observable, input: ${inputTypeName}) => Promise<${outputTypeName}>): Promise<void> {`);
-                    lines.push(`    await this.events.onReturnableEvent("${name}", obs, handler);`);
-                    lines.push(`  }`);
-                    break;
-                }
-                case 'onBroadcast': {
-                    const onMethodName = 'on' + methodName.charAt(0).toUpperCase() + methodName.slice(1);
-                    lines.push(`  /** ${description} */`);
-                    lines.push(`  async ${onMethodName}(obs: Observable, handler: (handlerObs: Observable, input: ${inputTypeName}) => Promise<void>): Promise<void> {`);
-                    lines.push(`    await this.events.onBroadcast("${name}", obs, handler);`);
-                    lines.push(`  }`);
-                    break;
-                }
+            if (clientCategory === 'emitEvents') {
+                lines.push(`  /** ${description} */`);
+                lines.push(`  async ${methodName}(obs: Observable, input: ${inputTypeName}): Promise<void> {`);
+                lines.push(`    await this.events.emitEvent("${name}", obs, input);`);
+                lines.push('  }');
+                continue;
+            }
+            if (clientCategory === 'emitReturnableEvents') {
+                const outputTypeName = `${typeName}Output`;
+                const timeout = def.defaultTimeout ?? 5;
+                lines.push(`  /** ${description} (default timeout: ${timeout}s) */`);
+                lines.push(`  async ${methodName}(obs: Observable, input: ${inputTypeName}, timeout: number = ${timeout}): Promise<${outputTypeName}> {`);
+                lines.push(`    return this.events.emitEventAndReturn("${name}", obs, input, timeout);`);
+                lines.push('  }');
+                continue;
+            }
+            if (clientCategory === 'emitBroadcast') {
+                const emitMethodName = `emit${methodName.charAt(0).toUpperCase()}${methodName.slice(1)}`;
+                lines.push(`  /** ${description} */`);
+                lines.push(`  async ${emitMethodName}(obs: Observable, input: ${inputTypeName}): Promise<void> {`);
+                lines.push(`    await this.events.emitBroadcast("${name}", obs, input);`);
+                lines.push('  }');
+                continue;
+            }
+            if (clientCategory === 'onEvents') {
+                const onMethodName = `on${methodName.charAt(0).toUpperCase()}${methodName.slice(1)}`;
+                lines.push(`  /** ${description} */`);
+                lines.push(`  async ${onMethodName}(obs: Observable, handler: (handlerObs: Observable, input: ${inputTypeName}) => Promise<void>): Promise<void> {`);
+                lines.push(`    await this.events.onEvent("${name}", obs, handler);`);
+                lines.push('  }');
+                continue;
+            }
+            if (clientCategory === 'onReturnableEvents') {
+                const outputTypeName = `${typeName}Output`;
+                const onMethodName = `on${methodName.charAt(0).toUpperCase()}${methodName.slice(1)}`;
+                lines.push(`  /** ${description} */`);
+                lines.push(`  async ${onMethodName}(obs: Observable, handler: (handlerObs: Observable, input: ${inputTypeName}) => Promise<${outputTypeName}>): Promise<void> {`);
+                lines.push(`    await this.events.onReturnableEvent("${name}", obs, handler);`);
+                lines.push('  }');
+                continue;
+            }
+            if (clientCategory === 'onBroadcast') {
+                const onMethodName = `on${methodName.charAt(0).toUpperCase()}${methodName.slice(1)}`;
+                lines.push(`  /** ${description} */`);
+                lines.push(`  async ${onMethodName}(obs: Observable, handler: (handlerObs: Observable, input: ${inputTypeName}) => Promise<void>): Promise<void> {`);
+                lines.push(`    await this.events.onBroadcast("${name}", obs, handler);`);
+                lines.push('  }');
             }
         }
     }
-    lines.push(`}`);
+    lines.push('}');
     lines.push(`export { ${className} };`);
     lines.push('');
     return lines.join('\n');
 }
-/**
- * Process schema files from a directory and generate virtual clients.
- */
 function processSchemaDirectory(schemasDir, clientsDir, importBase, skipPlugins) {
     let generated = 0;
     let errors = 0;
@@ -401,26 +228,20 @@ function processSchemaDirectory(schemasDir, clientsDir, importBase, skipPlugins)
         return { generated, errors };
     }
     const schemaFiles = fs.readdirSync(schemasDir)
-        .filter(file => file.endsWith('.json') && !file.endsWith('.plugin.json'));
+        .filter((file) => file.endsWith('.json') && !file.endsWith('.plugin.json'));
     for (const schemaFile of schemaFiles) {
         try {
             const pluginId = path.basename(schemaFile, '.json');
-            // Skip if already processed from a higher-priority source
-            if (skipPlugins && skipPlugins.has(pluginId)) {
+            if (skipPlugins?.has(pluginId)) {
                 continue;
             }
             const schemaPath = path.join(schemasDir, schemaFile);
-            const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
-            const schemaExport = JSON.parse(schemaContent);
-            // Skip schemas with no events
+            const schemaExport = JSON.parse(fs.readFileSync(schemaPath, 'utf-8'));
             if (!schemaExport.events || Object.keys(schemaExport.events).length === 0) {
                 continue;
             }
-            // Generate virtual client (use pluginId from filename, not pluginName from schema)
             const clientCode = generateVirtualClient(schemaExport, importBase, pluginId);
-            // Write to file
-            const outputPath = path.join(clientsDir, `${pluginId}.ts`);
-            fs.writeFileSync(outputPath, clientCode, 'utf-8');
+            fs.writeFileSync(path.join(clientsDir, `${pluginId}.ts`), clientCode, 'utf-8');
             // eslint-disable-next-line no-console
             console.log(`  Generated virtual client for ${pluginId} (v${schemaExport.version})`);
             generated++;
@@ -433,11 +254,6 @@ function processSchemaDirectory(schemasDir, clientsDir, importBase, skipPlugins)
     }
     return { generated, errors };
 }
-/**
- * Ensure the project's .gitignore contains the src/.bsb/ entry.
- * Automatically adds it if missing, so generated virtual clients
- * are never accidentally committed.
- */
 function ensureGitignore(projectRoot) {
     const gitignorePath = path.join(projectRoot, '.gitignore');
     const bsbDir = path.join(projectRoot, 'src', '.bsb');
@@ -449,7 +265,7 @@ function ensureGitignore(projectRoot) {
         if (fs.existsSync(gitignorePath)) {
             const content = fs.readFileSync(gitignorePath, 'utf-8');
             const lines = content.split(/\r?\n/);
-            const alreadyIgnored = lines.some(line => {
+            const alreadyIgnored = lines.some((line) => {
                 const trimmed = line.trim();
                 return trimmed === relativeBsbDir ||
                     trimmed === relativeBsbDir.replace(/\/$/, '') ||
@@ -460,27 +276,22 @@ function ensureGitignore(projectRoot) {
             });
             if (!alreadyIgnored) {
                 const newline = content.endsWith('\n') ? '' : '\n';
-                fs.writeFileSync(gitignorePath, content + newline + relativeBsbDir + '\n', 'utf-8');
+                fs.writeFileSync(gitignorePath, `${content}${newline}${relativeBsbDir}\n`, 'utf-8');
                 // eslint-disable-next-line no-console
                 console.log(`  Added '${relativeBsbDir}' to .gitignore`);
             }
+            return;
         }
-        else {
-            fs.writeFileSync(gitignorePath, relativeBsbDir + '\n', 'utf-8');
-            // eslint-disable-next-line no-console
-            console.log(`  Created .gitignore with '${relativeBsbDir}'`);
-        }
+        fs.writeFileSync(gitignorePath, `${relativeBsbDir}\n`, 'utf-8');
+        // eslint-disable-next-line no-console
+        console.log(`  Created .gitignore with '${relativeBsbDir}'`);
     }
     catch {
-        // Non-fatal: don't fail the build if we can't update .gitignore
+        // Non-fatal.
     }
 }
-/**
- * Main generation function.
- */
 async function main() {
     const projectRoot = process.cwd();
-    // Detect if we're in @bsb/base itself or a plugin project
     const packageJsonPath = path.join(projectRoot, 'package.json');
     let importBase = '@bsb/base';
     if (fs.existsSync(packageJsonPath)) {
@@ -491,20 +302,16 @@ async function main() {
             }
         }
         catch {
-            // ignore parse errors
+            // Ignore package.json parse errors for this helper script.
         }
     }
-    // Create output directory
     const clientsDir = path.join(projectRoot, 'src', '.bsb', 'clients');
     if (!fs.existsSync(clientsDir)) {
         fs.mkdirSync(clientsDir, { recursive: true });
     }
-    // Ensure .gitignore covers the generated directory
     ensureGitignore(projectRoot);
     let totalGenerated = 0;
     let totalErrors = 0;
-    // Schema source: src/.bsb/schemas/*.json
-    // These are extracted from TS source pre-compilation, or installed via `bsb client install`
     const bsbSchemasDir = path.join(projectRoot, 'src', '.bsb', 'schemas');
     if (fs.existsSync(bsbSchemasDir)) {
         // eslint-disable-next-line no-console
@@ -526,12 +333,12 @@ async function main() {
         process.exit(1);
     }
 }
-// Run if called directly
-if (require.main === module) {
-    main().catch(error => {
+if (isMainModule(import.meta.url)) {
+    main().catch((error) => {
         // eslint-disable-next-line no-console
         console.error('Fatal error during client generation:', error);
         process.exit(1);
     });
 }
+export { main as generateClientTypes };
 //# sourceMappingURL=generate-client-types.js.map