silgi 0.43.29 → 0.50.0

package/dist/codegen/emitters.d.mts

@@ -0,0 +1,51 @@
+//#region src/codegen/emitters.d.ts
+/**
+ * Schema emitters — code generation strategies for each Standard Schema library.
+ *
+ * Each emitter knows how to produce code strings for a specific validation library.
+ * The generic converter delegates to the active emitter.
+ */
+type SchemaTarget = 'zod' | 'valibot' | 'arktype';
+interface SchemaEmitter {
+  /** Import statement for the generated file */
+  importStatement: string;
+  /** Type inference helper: wraps a schema reference to extract its inferred type */
+  inferType(schemaExpr: string): string;
+  string(): string;
+  number(): string;
+  int(): string;
+  boolean(): string;
+  null(): string;
+  unknown(): string;
+  email(): string;
+  url(): string;
+  uuid(): string;
+  datetime(): string;
+  date(): string;
+  ipv4(): string;
+  ipv6(): string;
+  min(base: string, n: number): string;
+  max(base: string, n: number): string;
+  gt(base: string, n: number): string;
+  lt(base: string, n: number): string;
+  regex(base: string, pattern: string): string;
+  literal(value: unknown): string;
+  enum(values: unknown[]): string;
+  array(items: string): string;
+  object(entries: {
+    key: string;
+    value: string;
+    required: boolean;
+  }[]): string;
+  record(keySchema: string, valueSchema: string): string;
+  union(members: string[]): string;
+  discriminatedUnion(discriminator: string, members: string[]): string;
+  intersection(parts: string[]): string;
+  optional(base: string): string;
+  nullable(base: string): string;
+  default(base: string, value: unknown): string;
+  describe(base: string, description: string): string;
+}
+declare function getEmitter(target: SchemaTarget): SchemaEmitter;
+//#endregion
+export { SchemaEmitter, SchemaTarget, getEmitter };

package/dist/codegen/emitters.mjs

@@ -0,0 +1,143 @@
+//#region src/codegen/emitters.ts
+const zodEmitter = {
+	importStatement: "import { z } from 'zod'",
+	inferType: (expr) => `z.infer<typeof ${expr}>`,
+	string: () => "z.string()",
+	number: () => "z.number()",
+	int: () => "z.int()",
+	boolean: () => "z.boolean()",
+	null: () => "z.null()",
+	unknown: () => "z.unknown()",
+	email: () => "z.string().email()",
+	url: () => "z.string().url()",
+	uuid: () => "z.string().uuid()",
+	datetime: () => "z.string().datetime()",
+	date: () => "z.string().date()",
+	ipv4: () => "z.string().ip({ version: \"v4\" })",
+	ipv6: () => "z.string().ip({ version: \"v6\" })",
+	min: (base, n) => `${base}.min(${n})`,
+	max: (base, n) => `${base}.max(${n})`,
+	gt: (base, n) => `${base}.gt(${n})`,
+	lt: (base, n) => `${base}.lt(${n})`,
+	regex: (base, pattern) => `${base}.regex(/${pattern}/)`,
+	literal: (value) => `z.literal(${JSON.stringify(value)})`,
+	enum: (values) => `z.enum([${values.map((v) => JSON.stringify(v)).join(", ")}])`,
+	array: (items) => `z.array(${items})`,
+	object: (entries) => {
+		return `z.object({\n${entries.map(({ key, value, required }) => {
+			return `  ${isSafeIdentifier(key) ? key : JSON.stringify(key)}: ${value}${required ? "" : ".optional()"}`;
+		}).join(",\n")},\n})`;
+	},
+	record: (k, v) => `z.record(${k}, ${v})`,
+	union: (members) => `z.union([${members.join(", ")}])`,
+	discriminatedUnion: (disc, members) => `z.discriminatedUnion(${JSON.stringify(disc)}, [${members.join(", ")}])`,
+	intersection: (parts) => parts.reduce((acc, part) => `${acc}.and(${part})`),
+	optional: (base) => `${base}.optional()`,
+	nullable: (base) => `${base}.nullable()`,
+	default: (base, value) => `${base}.default(${JSON.stringify(value)})`,
+	describe: (base, desc) => `${base}.describe(${JSON.stringify(desc)})`
+};
+const valibotEmitter = {
+	importStatement: "import * as v from 'valibot'",
+	inferType: (expr) => `v.InferOutput<typeof ${expr}>`,
+	string: () => "v.string()",
+	number: () => "v.number()",
+	int: () => "v.pipe(v.number(), v.integer())",
+	boolean: () => "v.boolean()",
+	null: () => "v.null()",
+	unknown: () => "v.unknown()",
+	email: () => "v.pipe(v.string(), v.email())",
+	url: () => "v.pipe(v.string(), v.url())",
+	uuid: () => "v.pipe(v.string(), v.uuid())",
+	datetime: () => "v.pipe(v.string(), v.isoTimestamp())",
+	date: () => "v.pipe(v.string(), v.isoDate())",
+	ipv4: () => "v.pipe(v.string(), v.ipv4())",
+	ipv6: () => "v.pipe(v.string(), v.ipv6())",
+	min: (base, n) => wrapValibotPipe(base, `v.minValue(${n})`),
+	max: (base, n) => wrapValibotPipe(base, `v.maxValue(${n})`),
+	gt: (base, n) => wrapValibotPipe(base, `v.gtValue(${n})`),
+	lt: (base, n) => wrapValibotPipe(base, `v.ltValue(${n})`),
+	regex: (base, pattern) => wrapValibotPipe(base, `v.regex(/${pattern}/)`),
+	literal: (value) => `v.literal(${JSON.stringify(value)})`,
+	enum: (values) => `v.picklist([${values.map((v) => JSON.stringify(v)).join(", ")}])`,
+	array: (items) => `v.array(${items})`,
+	object: (entries) => {
+		const requiredEntries = entries.filter((e) => e.required);
+		const optionalEntries = entries.filter((e) => !e.required);
+		return `v.object({\n${[...requiredEntries.map(({ key, value }) => {
+			return `  ${isSafeIdentifier(key) ? key : JSON.stringify(key)}: ${value}`;
+		}), ...optionalEntries.map(({ key, value }) => {
+			return `  ${isSafeIdentifier(key) ? key : JSON.stringify(key)}: v.optional(${value})`;
+		})].join(",\n")},\n})`;
+	},
+	record: (_k, v) => `v.record(v.string(), ${v})`,
+	union: (members) => `v.union([${members.join(", ")}])`,
+	discriminatedUnion: (disc, members) => `v.variant(${JSON.stringify(disc)}, [${members.join(", ")}])`,
+	intersection: (parts) => `v.intersect([${parts.join(", ")}])`,
+	optional: (base) => `v.optional(${base})`,
+	nullable: (base) => `v.nullable(${base})`,
+	default: (base, value) => `v.optional(${base}, ${JSON.stringify(value)})`,
+	describe: (base, desc) => `v.pipe(${base}, v.description(${JSON.stringify(desc)}))`
+};
+/**
+* Valibot uses `v.pipe(schema, ...actions)` for constraints.
+* If the base is already a pipe, inject the action into it.
+*/
+function wrapValibotPipe(base, action) {
+	if (base.startsWith("v.pipe(") && base.endsWith(")")) return `${base.slice(0, -1)}, ${action})`;
+	return `v.pipe(${base}, ${action})`;
+}
+const emitters = {
+	zod: zodEmitter,
+	valibot: valibotEmitter,
+	arktype: {
+		importStatement: "import { type } from 'arktype'",
+		inferType: (expr) => `typeof ${expr}.infer`,
+		string: () => "type('string')",
+		number: () => "type('number')",
+		int: () => "type('number.integer')",
+		boolean: () => "type('boolean')",
+		null: () => "type('null')",
+		unknown: () => "type('unknown')",
+		email: () => "type('string.email')",
+		url: () => "type('string.url')",
+		uuid: () => "type('string.uuid')",
+		datetime: () => "type('string.date.iso')",
+		date: () => "type('string.date')",
+		ipv4: () => "type('string.ip')",
+		ipv6: () => "type('string.ip')",
+		min: (base, n) => `${base}.atLeast(${n})`,
+		max: (base, n) => `${base}.atMost(${n})`,
+		gt: (base, n) => `${base}.moreThan(${n})`,
+		lt: (base, n) => `${base}.lessThan(${n})`,
+		regex: (base, pattern) => `${base}.matching(/${pattern}/)`,
+		literal: (value) => `type(${JSON.stringify(JSON.stringify(value))})`,
+		enum: (values) => {
+			return `type(${values.map((v) => JSON.stringify(JSON.stringify(v))).join(" + ' | ' + ")})`;
+		},
+		array: (items) => `${items}.array()`,
+		object: (entries) => {
+			return `type({\n${entries.map(({ key, value, required }) => {
+				return `  [${required ? JSON.stringify(key) : JSON.stringify(`${key}?`)}]: ${value}`;
+			}).join(",\n")},\n})`;
+		},
+		record: (_k, v) => `type({ '[string]': ${v} })`,
+		union: (members) => members.reduce((acc, m) => `${acc}.or(${m})`),
+		discriminatedUnion: (_disc, members) => members.reduce((acc, m) => `${acc}.or(${m})`),
+		intersection: (parts) => parts.reduce((acc, p) => `${acc}.and(${p})`),
+		optional: (base) => `${base}.optional()`,
+		nullable: (base) => `${base}.or(type('null'))`,
+		default: (base, value) => `${base}.default(${JSON.stringify(value)})`,
+		describe: (base, desc) => `${base}.describe(${JSON.stringify(desc)})`
+	}
+};
+function getEmitter(target) {
+	const emitter = emitters[target];
+	if (!emitter) throw new Error(`Unknown schema target: ${target}`);
+	return emitter;
+}
+function isSafeIdentifier(s) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(s);
+}
+//#endregion
+export { getEmitter };

package/dist/codegen/generate.d.mts

@@ -0,0 +1,25 @@
+import { ParsedOperation } from "./parse.mjs";
+import { SchemaTarget } from "./emitters.mjs";
+
+//#region src/codegen/generate.d.ts
+interface GenerateOptions {
+  /** How to group operations into folders: by tag, by first path segment, or flat */
+  groupBy?: 'tag' | 'path' | 'flat';
+  /** Silgi instance variable name (default: "s") */
+  instanceName?: string;
+  /** Custom header comment */
+  header?: string;
+  /** Target schema library (default: "zod") */
+  schema?: SchemaTarget;
+}
+interface GeneratedFiles {
+  /** schemas.gen.ts — validation schemas for all components + operation I/O */
+  schemas: string;
+  /** router.gen.ts — root router importing all operation files */
+  router: string;
+  /** routes/<group>/<operationId>.ts — one file per operation */
+  routes: Map<string, string>;
+}
+declare function generateCode(operations: ParsedOperation[], components: Record<string, Record<string, unknown>>, options?: GenerateOptions): GeneratedFiles;
+//#endregion
+export { GenerateOptions, generateCode };

package/dist/codegen/generate.mjs

@@ -0,0 +1,224 @@
+import { getEmitter } from "./emitters.mjs";
+import { createSchemaContext, emitComponentSchemas, jsonSchemaToCode } from "./schema-to-code.mjs";
+//#region src/codegen/generate.ts
+/**
+* Code generator — one file per operation, inline $resolve, URL-based grouping.
+*
+* Output structure:
+*   schemas.gen.ts              — Shared validation schemas
+*   router.gen.ts               — Root router importing all operation files
+*   routes/
+*     pets/
+*       listPets.ts             — Single operation with inline $resolve
+*       createPet.ts
+*     store/
+*       getInventory.ts
+*/
+const STATUS_TO_ERROR_CODE = {
+	400: "BAD_REQUEST",
+	401: "UNAUTHORIZED",
+	403: "FORBIDDEN",
+	404: "NOT_FOUND",
+	405: "METHOD_NOT_ALLOWED",
+	408: "TIMEOUT",
+	409: "CONFLICT",
+	410: "GONE",
+	422: "UNPROCESSABLE_ENTITY",
+	429: "TOO_MANY_REQUESTS",
+	500: "INTERNAL_SERVER_ERROR",
+	502: "BAD_GATEWAY",
+	503: "SERVICE_UNAVAILABLE"
+};
+function generateCode(operations, components, options = {}) {
+	const { groupBy = "tag", instanceName = "s", header = "// This file is auto-generated by silgi/codegen — DO NOT EDIT", schema: target = "zod" } = options;
+	const emitter = getEmitter(target);
+	const ctx = createSchemaContext(target, components);
+	const operationSchemas = [];
+	const operationSchemaNames = /* @__PURE__ */ new Map();
+	for (const op of operations) {
+		const names = {};
+		const inputSchema = buildInputSchema(op, ctx);
+		if (inputSchema) {
+			const name = `${op.operationId}Input`;
+			operationSchemas.push(`export const ${name}Schema = ${inputSchema}`);
+			names.input = `${name}Schema`;
+		}
+		if (op.successSchema) {
+			const name = `${op.operationId}Output`;
+			const code = jsonSchemaToCode(op.successSchema, ctx);
+			operationSchemas.push(`export const ${name}Schema = ${code}`);
+			names.output = `${name}Schema`;
+		}
+		operationSchemaNames.set(op.operationId, names);
+	}
+	const componentCode = emitComponentSchemas(ctx);
+	const schemasFile = [
+		header,
+		emitter.importStatement,
+		"",
+		"// ── Component Schemas ──",
+		"",
+		componentCode,
+		"",
+		"// ── Operation Schemas ──",
+		"",
+		operationSchemas.join("\n\n"),
+		""
+	].join("\n");
+	const groups = groupOperations(operations, groupBy);
+	const routeFiles = /* @__PURE__ */ new Map();
+	for (const [groupName, ops] of groups) for (const op of ops) {
+		const filePath = `${groupName}/${op.operationId}`;
+		routeFiles.set(filePath, generateOperationFile(op, operationSchemaNames, {
+			header: header.replace("DO NOT EDIT", "Implement your resolver"),
+			instanceName,
+			schemasImportPath: "../../schemas.gen.ts"
+		}));
+	}
+	return {
+		schemas: schemasFile,
+		router: generateRootRouter(groups, operationSchemaNames, {
+			header,
+			instanceName
+		}),
+		routes: routeFiles
+	};
+}
+function buildInputSchema(op, ctx) {
+	const e = ctx.emitter;
+	const parts = [];
+	for (const p of op.pathParams) parts.push({
+		key: p.name,
+		value: jsonSchemaToCode(p.schema, ctx),
+		required: true
+	});
+	for (const p of op.queryParams) parts.push({
+		key: p.name,
+		value: jsonSchemaToCode(p.schema, ctx),
+		required: p.required
+	});
+	if (op.body) if (op.body.type === "object" && op.body.properties && !hasOverlap(parts, op.body.properties)) {
+		const required = new Set(op.body.required ?? []);
+		for (const [key, prop] of Object.entries(op.body.properties)) parts.push({
+			key,
+			value: jsonSchemaToCode(prop, ctx),
+			required: required.has(key)
+		});
+	} else parts.push({
+		key: "body",
+		value: jsonSchemaToCode(op.body, ctx),
+		required: op.bodyRequired
+	});
+	if (parts.length === 0) return null;
+	return e.object(parts);
+}
+function hasOverlap(parts, properties) {
+	const existing = new Set(parts.map((p) => p.key));
+	return Object.keys(properties).some((k) => existing.has(k));
+}
+function generateOperationFile(op, schemaNames, opts) {
+	const s = opts.instanceName;
+	const names = schemaNames.get(op.operationId) ?? {};
+	const lines = [
+		opts.header,
+		"import { silgi, SilgiError } from 'silgi'",
+		`import * as schemas from '${opts.schemasImportPath}'`,
+		"",
+		`const ${s} = silgi()`,
+		""
+	];
+	if (op.summary) lines.push(`/** ${op.summary} */`);
+	lines.push(`export const ${op.operationId} = ${s}`);
+	const routeParts = [];
+	routeParts.push(`    path: '${op.silgiPath}',`);
+	routeParts.push(`    method: '${op.method}',`);
+	if (op.summary) routeParts.push(`    summary: ${JSON.stringify(op.summary)},`);
+	if (op.tags.length) routeParts.push(`    tags: [${op.tags.map((t) => JSON.stringify(t)).join(", ")}],`);
+	if (op.deprecated) routeParts.push("    deprecated: true,");
+	routeParts.push(`    operationId: ${JSON.stringify(op.operationId)},`);
+	if (op.successStatus !== 200) routeParts.push(`    successStatus: ${op.successStatus},`);
+	if (op.security === false) routeParts.push("    security: false,");
+	else if (op.security) routeParts.push(`    security: [${op.security.map((v) => JSON.stringify(v)).join(", ")}],`);
+	lines.push(`  .$route({`);
+	lines.push(routeParts.join("\n"));
+	lines.push(`  })`);
+	if (names.input) lines.push(`  .$input(schemas.${names.input})`);
+	if (names.output) lines.push(`  .$output(schemas.${names.output})`);
+	if (op.errors.size > 0) {
+		const errorEntries = [];
+		for (const [status, { description }] of op.errors) {
+			const code = STATUS_TO_ERROR_CODE[status] ?? `ERROR_${status}`;
+			const finalCode = description && /^[A-Z_]+$/.test(description) ? description : code;
+			errorEntries.push(`    ${finalCode}: ${status},`);
+		}
+		lines.push(`  .$errors({`);
+		lines.push(errorEntries.join("\n"));
+		lines.push(`  })`);
+	}
+	lines.push(`  .$resolve(({ input, ctx, fail }) => {`);
+	lines.push(`    // TODO: implement ${op.operationId}`);
+	lines.push(`    throw new SilgiError({`);
+	lines.push(`      code: 'INTERNAL_SERVER_ERROR',`);
+	lines.push(`      message: 'Not implemented: ${op.operationId}',`);
+	lines.push(`    })`);
+	lines.push(`  })`);
+	lines.push("");
+	return lines.join("\n");
+}
+function generateRootRouter(groups, _schemaNames, opts) {
+	const s = opts.instanceName;
+	const lines = [
+		opts.header,
+		"import { silgi } from 'silgi'",
+		""
+	];
+	for (const [groupName, ops] of groups) for (const op of ops) lines.push(`import { ${op.operationId} } from './routes/${groupName}/${op.operationId}.ts'`);
+	lines.push("");
+	lines.push(`const ${s} = silgi()`);
+	lines.push("");
+	if (groups.size === 1 && groups.has("default")) {
+		const ops = groups.get("default");
+		lines.push(`export const router = ${s}.router({`);
+		for (const op of ops) lines.push(`  ${op.operationId},`);
+		lines.push("})");
+	} else {
+		lines.push(`export const router = ${s}.router({`);
+		for (const [groupName, ops] of groups) {
+			const safeName = isSafeIdentifier(groupName) ? groupName : JSON.stringify(groupName);
+			lines.push(`  ${safeName}: {`);
+			for (const op of ops) lines.push(`    ${op.operationId},`);
+			lines.push(`  },`);
+		}
+		lines.push("})");
+	}
+	lines.push("");
+	lines.push("export type AppRouter = typeof router");
+	lines.push("");
+	return lines.join("\n");
+}
+function groupOperations(operations, groupBy) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const op of operations) {
+		let key;
+		switch (groupBy) {
+			case "tag":
+				key = op.tags[0] ?? "default";
+				break;
+			case "path":
+				key = op.path.split("/").find(Boolean) ?? "default";
+				break;
+			case "flat":
+				key = "default";
+				break;
+		}
+		key = key.replace(/[^a-zA-Z0-9_]/g, "_");
+		if (!groups.has(key)) groups.set(key, []);
+		groups.get(key).push(op);
+	}
+	return groups;
+}
+function isSafeIdentifier(s) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(s);
+}
+//#endregion
+export { generateCode };

package/dist/codegen/index.d.mts

@@ -0,0 +1,44 @@
+import { OpenAPISpec, ParsedOperation, parseOpenAPI } from "./parse.mjs";
+import { SchemaEmitter, SchemaTarget, getEmitter } from "./emitters.mjs";
+import { GenerateOptions, generateCode } from "./generate.mjs";
+import { SchemaContext, createSchemaContext, jsonSchemaToCode } from "./schema-to-code.mjs";
+import { extractResolveBody, spliceResolveBody } from "./preserve.mjs";
+
+//#region src/codegen/index.d.ts
+interface GenerateFromSpecOptions extends GenerateOptions {
+  /** Path to OpenAPI spec file (JSON or YAML) or a spec object */
+  spec: string | OpenAPISpec;
+  /** Output directory for generated files (default: "./generated") */
+  outDir?: string;
+  /**
+   * What to do when route files already exist:
+   * - "smart" (default) — regenerate $route/$input/$output/$errors, preserve $resolve body
+   * - "skip" — don't touch existing route files at all
+   * - "overwrite" — regenerate everything including $resolve
+   */
+  routeStrategy?: 'smart' | 'skip' | 'overwrite';
+}
+interface GenerateResult {
+  /** Paths of all generated files */
+  files: string[];
+  /** Number of operations processed */
+  operationCount: number;
+  /** Number of component schemas generated */
+  schemaCount: number;
+}
+/**
+ * Generate Silgi code from an OpenAPI spec file or object.
+ */
+declare function generateFromSpec(options: GenerateFromSpecOptions): Promise<GenerateResult>;
+/**
+ * Generate Silgi code without writing to disk.
+ * Useful for programmatic use or custom output handling.
+ */
+declare function generate(spec: OpenAPISpec, options?: GenerateOptions): {
+  schemas: string;
+  router: string;
+  routes: Map<string, string>;
+  operations: ReturnType<typeof parseOpenAPI>['operations'];
+};
+//#endregion
+export { GenerateFromSpecOptions, type GenerateOptions, GenerateResult, type OpenAPISpec, type ParsedOperation, type SchemaContext, type SchemaEmitter, type SchemaTarget, createSchemaContext, extractResolveBody, generate, generateCode, generateFromSpec, getEmitter, jsonSchemaToCode, parseOpenAPI, spliceResolveBody };

package/dist/codegen/index.mjs

@@ -0,0 +1,103 @@
+import { getEmitter } from "./emitters.mjs";
+import { createSchemaContext, jsonSchemaToCode } from "./schema-to-code.mjs";
+import { generateCode } from "./generate.mjs";
+import { parseOpenAPI } from "./parse.mjs";
+import { extractResolveBody, spliceResolveBody } from "./preserve.mjs";
+import { extname, join, resolve } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+//#region src/codegen/index.ts
+/**
+* silgi/codegen — OpenAPI → Silgi code generator.
+*
+* Takes an OpenAPI 3.x spec and generates:
+* - Validation schemas (Zod, Valibot, or ArkType) for all components and operation I/O
+* - Co-located route modules (handlers + procedures in the same file, per domain)
+* - Root router that combines all route modules
+*
+* @example
+* ```ts
+* import { generateFromSpec } from 'silgi/codegen'
+*
+* await generateFromSpec({
+*   spec: './openapi.json',
+*   outDir: './src/generated',
+*   schema: 'zod', // or 'valibot' or 'arktype'
+* })
+* ```
+*/
+/**
+* Generate Silgi code from an OpenAPI spec file or object.
+*/
+async function generateFromSpec(options) {
+	const { outDir = "./generated", routeStrategy = "smart", ...genOpts } = options;
+	const { operations, components, tags: _tags } = parseOpenAPI(typeof options.spec === "string" ? await loadSpec(options.spec) : options.spec);
+	const { schemas, router, routes } = generateCode(operations, components, genOpts);
+	const outputDir = resolve(outDir);
+	await mkdir(outputDir, { recursive: true });
+	const files = [];
+	const schemasPath = join(outputDir, "schemas.gen.ts");
+	await writeFile(schemasPath, schemas, "utf-8");
+	files.push(schemasPath);
+	const routerPath = join(outputDir, "router.gen.ts");
+	await writeFile(routerPath, router, "utf-8");
+	files.push(routerPath);
+	if (routes.size > 0) {
+		const { extractResolveBody, spliceResolveBody } = await import("./preserve.mjs");
+		for (const [filePath, code] of routes) {
+			const fullPath = join(outputDir, "routes", `${filePath}.ts`);
+			await mkdir(join(fullPath, ".."), { recursive: true });
+			if (routeStrategy === "skip") {
+				if (await fileExists(fullPath)) continue;
+			}
+			if (routeStrategy === "smart" && await fileExists(fullPath)) {
+				const preserved = extractResolveBody(await readFile(fullPath, "utf-8"));
+				if (preserved) await writeFile(fullPath, spliceResolveBody(code, preserved), "utf-8");
+				else await writeFile(fullPath, code, "utf-8");
+				files.push(fullPath);
+				continue;
+			}
+			await writeFile(fullPath, code, "utf-8");
+			files.push(fullPath);
+		}
+	}
+	const schemaCount = (schemas.match(/^export const \w+Schema/gm) ?? []).length;
+	return {
+		files,
+		operationCount: operations.length,
+		schemaCount
+	};
+}
+/**
+* Generate Silgi code without writing to disk.
+* Useful for programmatic use or custom output handling.
+*/
+function generate(spec, options = {}) {
+	const { operations, components } = parseOpenAPI(spec);
+	return {
+		...generateCode(operations, components, options),
+		operations
+	};
+}
+async function loadSpec(path) {
+	const resolved = resolve(path);
+	const content = await readFile(resolved, "utf-8");
+	const ext = extname(resolved).toLowerCase();
+	if (ext === ".yaml" || ext === ".yml") try {
+		const { parse } = await import("yaml");
+		return parse(content);
+	} catch {
+		throw new Error("YAML spec detected but \"yaml\" package is not installed. Install it with: pnpm add -D yaml");
+	}
+	return JSON.parse(content);
+}
+async function fileExists(path) {
+	try {
+		const { access } = await import("node:fs/promises");
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { createSchemaContext, extractResolveBody, generate, generateCode, generateFromSpec, getEmitter, jsonSchemaToCode, parseOpenAPI, spliceResolveBody };