sizuku 0.3.1 → 0.4.0

package/dist/index.mjs

@@ -0,0 +1,1615 @@
+import { config } from "./config/index.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { format } from "prettier";
+import fsp from "node:fs/promises";
+import { Node, Project } from "ts-morph";
+import { generateDBMLContent, makeCapitalized, makeCapitalized as makeCapitalized$1, makeCleanedCommentLines, makeValibotInfer, makeValibotObject, makeZodInfer, makeZodObject, mapDrizzleType } from "utils-lab";
+import { Resvg } from "@resvg/resvg-js";
+import { run } from "@softwaretechnik/dbml-renderer";
+
+//#region src/shared/format/index.ts
+/**
+* Formats TypeScript source with Prettier.
+*
+* @param code - Source code to format.
+* @returns A `Result` containing the formatted code or an error message.
+*/
+async function fmt(code) {
+	try {
+		return {
+			ok: true,
+			value: await format(code, {
+				parser: "typescript",
+				printWidth: 100,
+				singleQuote: true,
+				semi: false
+			})
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+
+//#endregion
+//#region src/shared/fsp/index.ts
+/**
+* Creates a directory if it does not already exist.
+*
+* @param dir - Directory path to create.
+* @returns A `Result` that is `ok` on success, otherwise an error message.
+*/
+async function mkdir(dir) {
+	try {
+		await fsp.mkdir(dir, { recursive: true });
+		return {
+			ok: true,
+			value: void 0
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+/**
+* Writes UTF-8 text to a file, creating it if necessary.
+*
+* @param path - File path to write.
+* @param data - Text data to write.
+* @returns A `Result` that is `ok` on success, otherwise an error message.
+*/
+async function writeFile(path, data) {
+	try {
+		await fsp.writeFile(path, data, "utf-8");
+		return {
+			ok: true,
+			value: void 0
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+/**
+* Writes binary data to a file, creating it if necessary.
+*
+* @param path - File path to write.
+* @param data - Binary data to write.
+* @returns A `Result` that is `ok` on success, otherwise an error message.
+*/
+async function writeFileBinary(path, data) {
+	try {
+		await fsp.writeFile(path, data);
+		return {
+			ok: true,
+			value: void 0
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+
+//#endregion
+//#region src/utils/index.ts
+/**
+* Check if a string starts with a prefix.
+*
+* @param str - The input string.
+* @param prefix - The prefix to check.
+* @returns True if string starts with prefix.
+*/
+function startsWith(str, prefix) {
+	return str.indexOf(prefix) === 0;
+}
+/**
+* Trim whitespace from string.
+*
+* @param str - The input string.
+* @returns Trimmed string.
+*/
+function trimString(str) {
+	return str.trim();
+}
+/**
+* Clean comment lines by removing triple slash prefix and trimming.
+* Uses makeCleanedCommentLines from utils-lab.
+*
+* @param commentLines - Raw comment lines
+* @returns Cleaned comment lines
+*/
+function cleanCommentLines(commentLines) {
+	return makeCleanedCommentLines(commentLines);
+}
+/**
+* Extract object type from comment lines.
+*
+* @param cleaned - Cleaned comment lines
+* @param tag - The tag to look for
+* @returns The object type if found
+*/
+function extractObjectType(cleaned, tag) {
+	const tagWithoutAt = tag.slice(1);
+	const objectTypeLine = cleaned.find((line) => line.includes(`${tagWithoutAt}strictObject`) || line.includes(`${tagWithoutAt}looseObject`));
+	if (!objectTypeLine) return void 0;
+	if (objectTypeLine.includes("strictObject")) return "strict";
+	if (objectTypeLine.includes("looseObject")) return "loose";
+}
+/**
+* Extract definition from comment lines.
+*
+* @param cleaned - Cleaned comment lines
+* @param tag - The tag to look for
+* @returns The definition string
+*/
+function extractDefinition(cleaned, tag) {
+	const definitionLine = cleaned.find((line) => line.startsWith(tag) && !line.includes("strictObject") && !line.includes("looseObject"));
+	if (!definitionLine) return "";
+	const withoutAt = definitionLine.startsWith("@") ? definitionLine.substring(1) : definitionLine;
+	if (tag === "@a." || tag === "@e.") {
+		const prefix = tag.substring(1);
+		return withoutAt.startsWith(prefix) ? withoutAt.substring(prefix.length) : withoutAt;
+	}
+	return withoutAt;
+}
+/**
+* Extract description from comment lines.
+*
+* @param cleaned - Cleaned comment lines
+* @returns The description if found
+*/
+function extractDescription(cleaned) {
+	const descriptionLines = cleaned.filter((line) => !(line.includes("@z.") || line.includes("@v.") || line.includes("@a.") || line.includes("@e.") || line.includes("@relation.")));
+	return descriptionLines.length > 0 ? descriptionLines.join(" ") : void 0;
+}
+/**
+* Parse field comments and extract definition line and description.
+*
+* @param commentLines - Raw comment lines (e.g., from source text)
+* @param tag - The tag to look for (e.g., '@v.', '@z.', '@a.', or '@e.')
+* @returns Parsed definition and description
+*/
+function parseFieldComments(commentLines, tag) {
+	const cleaned = cleanCommentLines(commentLines);
+	const objectType = extractObjectType(cleaned, tag);
+	return {
+		definition: extractDefinition(cleaned, tag),
+		description: extractDescription(cleaned),
+		objectType
+	};
+}
+/**
+* Process a single line during comment extraction.
+*
+* @param acc - The accumulator
+* @param line - The line to process
+* @returns Updated accumulator
+*/
+function processCommentLine(acc, line) {
+	if (acc.shouldStop) return acc;
+	if (line.startsWith("///")) return {
+		commentLines: [line, ...acc.commentLines],
+		shouldStop: false
+	};
+	if (line === "") return acc;
+	return {
+		commentLines: acc.commentLines,
+		shouldStop: true
+	};
+}
+/**
+* Extract field comments from source text.
+*
+* @param sourceText - The source text to extract comments from.
+* @param fieldStartPos - The position of the field in the source text.
+* @returns An array of comment lines.
+*/
+function extractFieldComments(sourceText, fieldStartPos) {
+	return sourceText.substring(0, fieldStartPos).split("\n").map((line, index) => ({
+		line: line.trim(),
+		index
+	})).reverse().reduce((acc, { line }) => processCommentLine(acc, line), {
+		commentLines: [],
+		shouldStop: false
+	}).commentLines;
+}
+/**
+* Creates `z.infer` type for the specified model.
+* Uses makeZodInfer from utils-lab with capitalized model name.
+*
+* @param name - The model name
+* @returns The generated TypeScript type definition line using Zod.
+*/
+function infer(name) {
+	return makeZodInfer(makeCapitalized(name));
+}
+/**
+* Creates `v.InferInput` type for the specified model.
+* Uses makeValibotInfer from utils-lab with capitalized model name.
+*
+* @param name - The model name
+* @returns The generated TypeScript type definition line using Valibot.
+*/
+function inferInput(name) {
+	return makeValibotInfer(makeCapitalized(name));
+}
+/**
+* @param schema
+* @returns
+*/
+function fieldDefinitions(schema, comment) {
+	return schema.fields.map(({ name, definition, description }) => {
+		return `${description && comment ? `/**\n* ${description}\n*/\n` : ""}${name}:${definition}`;
+	}).join(",\n");
+}
+/**
+* Creates ArkType infer type for the specified model.
+*
+* @param name - The model name
+* @returns The generated TypeScript type definition line using ArkType.
+*/
+function inferArktype(name) {
+	const capitalized = makeCapitalized(name);
+	return `export type ${capitalized} = typeof ${capitalized}Schema.infer`;
+}
+/**
+* Creates Effect Schema infer type for the specified model.
+*
+* @param name - The model name
+* @returns The generated TypeScript type definition line using Effect Schema.
+*/
+function inferEffect(name) {
+	const capitalized = makeCapitalized(name);
+	return `export type ${capitalized} = Schema.Schema.Type<typeof ${capitalized}Schema>`;
+}
+
+//#endregion
+//#region src/shared/helper/extract-schemas.ts
+/**
+* Generates relation definition based on function name and reference table.
+*
+* @param fnName - The relation function name ('many' or 'one')
+* @param refTable - The referenced table name
+* @param prefix - Schema prefix for validation library
+* @returns The generated relation definition string
+*/
+function generateRelationDefinition(fnName, refTable, prefix) {
+	const schema = `${makeCapitalized$1(refTable)}Schema`;
+	if (fnName === "many") {
+		if (prefix === "type") return `${schema}.array()`;
+		if (prefix === "Schema") return `Schema.Array(${schema})`;
+		return `${prefix}.array(${schema})`;
+	}
+	if (fnName === "one") return schema;
+	return "";
+}
+/**
+* Processes arrow function body to find object literal expression.
+*
+* @param body - The arrow function body node
+* @returns The found object literal expression, or null if not found
+*/
+function processArrowFunctionBody(body) {
+	if (Node.isObjectLiteralExpression(body)) return body;
+	if (Node.isParenthesizedExpression(body)) return findObjectLiteralExpression(body.getExpression());
+	if (Node.isBlock(body)) {
+		const ret = body.getStatements().find(Node.isReturnStatement);
+		if (ret && Node.isReturnStatement(ret)) {
+			const re = ret.getExpression();
+			return re && Node.isObjectLiteralExpression(re) ? re : null;
+		}
+	}
+	return null;
+}
+/**
+* Recursively extracts an `ObjectLiteralExpression` from a given AST node.
+*
+* @param expr - The root `Node` to search for object literals
+* @returns The found `ObjectLiteralExpression`, or `null` if not found
+*/
+function findObjectLiteralExpression(expr) {
+	if (Node.isObjectLiteralExpression(expr)) return expr;
+	if (Node.isParenthesizedExpression(expr)) return findObjectLiteralExpression(expr.getExpression());
+	if (Node.isArrowFunction(expr)) return processArrowFunctionBody(expr.getBody());
+	return null;
+}
+/**
+* Finds an object literal expression in call expression arguments.
+*
+* @param call - The call expression to search for object literals in its arguments
+* @param finder - Function to find object literal in a node
+* @returns The found object literal, or `null` if not found in any argument
+*/
+function findObjectLiteralInArgs(call, finder) {
+	for (const arg of call.getArguments()) {
+		const obj = finder(arg);
+		if (obj) return obj;
+	}
+	return null;
+}
+/**
+* Determines whether a given `CallExpression` is a relation-related function call.
+*
+* @param callExpr - The call expression node to check for relation functions
+* @returns `true` if the function is a relation function; otherwise, `false`
+*/
+function isRelationFunctionCall(callExpr) {
+	const expression = callExpr.getExpression();
+	if (!Node.isIdentifier(expression)) return false;
+	const functionName = expression.getText();
+	return functionName === "relations" || functionName.includes("relation");
+}
+/**
+* Creates a field extractor function using a custom parseFieldComments implementation.
+*
+* @param parseFieldComments - A function that parses comment lines into { definition, description, objectType }
+* @returns A property node extractor function
+*/
+function createExtractFieldFromProperty(parseFieldComments) {
+	return (property, sourceText) => {
+		if (!Node.isPropertyAssignment(property)) return null;
+		const name = property.getName();
+		if (!name) return null;
+		const { definition, description } = parseFieldComments(extractFieldComments(sourceText, property.getStart()));
+		return {
+			name,
+			definition,
+			description
+		};
+	};
+}
+/**
+* Creates a relation field extractor function.
+*
+* @param parseFieldComments - Function to parse field comments
+* @param prefix - Schema prefix for validation library
+* @returns Function that extracts relation fields from property
+*/
+function createExtractRelationFieldFromProperty(parseFieldComments, prefix) {
+	return (property, sourceText) => {
+		if (!Node.isPropertyAssignment(property)) return null;
+		const name = property.getName();
+		if (!name) return null;
+		const init = property.getInitializer();
+		if (!Node.isCallExpression(init)) return {
+			name,
+			definition: "",
+			description: void 0
+		};
+		const expr = init.getExpression();
+		if (!Node.isIdentifier(expr)) return {
+			name,
+			definition: "",
+			description: void 0
+		};
+		const fnName = expr.getText();
+		const args = init.getArguments();
+		if (!(args.length && Node.isIdentifier(args[0]))) return {
+			name,
+			definition: "",
+			description: void 0
+		};
+		const definition = generateRelationDefinition(fnName, args[0].getText(), prefix);
+		const { description } = parseFieldComments(extractFieldComments(sourceText, property.getStart()));
+		return {
+			name,
+			definition,
+			description
+		};
+	};
+}
+/**
+* Extracts fields from object literal properties using appropriate extractor.
+*
+* @param properties - Array of object literal properties
+* @param isRelation - Whether this is a relation function call
+* @param extractFieldFromProperty - Function to extract regular fields
+* @param extractRelationFieldFromProperty - Function to extract relation fields
+* @param sourceText - The source text for comment extraction
+* @returns Array of extracted field results
+*/
+function extractFieldsFromProperties(properties, isRelation, extractFieldFromProperty, extractRelationFieldFromProperty, sourceText) {
+	return properties.map((prop) => isRelation ? extractRelationFieldFromProperty(prop, sourceText) : extractFieldFromProperty(prop, sourceText)).filter((field) => field !== null);
+}
+/**
+* Creates a field extractor for call expressions with customizable strategies.
+*
+* @param extractFieldFromProperty - Function to extract field from property
+* @param extractRelationFieldFromProperty - Function to extract relation field from property
+* @param findObjectLiteralExpression - Function to find object literal expression
+* @param findObjectLiteralInArgs - Function to find object literal in call arguments
+* @param isRelationFunctionCall - Function to check if call is relation function
+* @returns Function that extracts fields from call expression
+*/
+function createExtractFieldsFromCallExpression(extractFieldFromProperty, extractRelationFieldFromProperty, findObjectLiteralExpression, findObjectLiteralInArgs, isRelationFunctionCall) {
+	return (callExpr, sourceText) => {
+		const objectLiteral = findObjectLiteralInArgs(callExpr, findObjectLiteralExpression);
+		if (!objectLiteral) return [];
+		const isRelation = isRelationFunctionCall(callExpr);
+		return extractFieldsFromProperties(objectLiteral.getProperties(), isRelation, extractFieldFromProperty, extractRelationFieldFromProperty, sourceText);
+	};
+}
+/**
+* Creates a schema extractor from customizable strategies.
+*
+* @param extractFieldsFromCall - Function to extract fields from a call expression
+* @param extractFieldFromProperty - Function to extract a single field from an object literal property
+* @param parseFieldComments - Function to parse field comments with object type support
+* @param commentPrefix - The comment prefix to use for parsing
+* @returns A function that extracts a schema from a variable declaration node
+*/
+function buildSchemaExtractor(extractFieldsFromCall, extractFieldFromProperty, parseFieldComments, commentPrefix) {
+	return (variableStatement, sourceText, originalSourceCode) => {
+		if (!Node.isVariableStatement(variableStatement)) return null;
+		const declarations = variableStatement.getDeclarations();
+		if (declarations.length === 0) return null;
+		const declaration = declarations[0];
+		const name = declaration.getName();
+		if (!name) return null;
+		const statementStart = variableStatement.getStart();
+		const originalSourceLines = originalSourceCode.split("\n");
+		const commentLines = [];
+		let lineNumber = 0;
+		let charCount = 0;
+		for (let i = 0; i < originalSourceLines.length; i++) {
+			if (charCount >= statementStart) {
+				lineNumber = i;
+				break;
+			}
+			charCount += originalSourceLines[i].length + 1;
+		}
+		for (let i = lineNumber - 1; i >= 0; i--) {
+			const line = originalSourceLines[i];
+			const trimmedLine = trimString(line);
+			if (trimmedLine === "") continue;
+			if (startsWith(trimmedLine, "///")) commentLines.unshift(line);
+			else break;
+		}
+		const { objectType } = parseFieldComments(commentLines, commentPrefix);
+		const initializer = declaration.getInitializer();
+		if (Node.isCallExpression(initializer)) {
+			if (isRelationFunctionCall(initializer)) return null;
+			return {
+				name,
+				fields: extractFieldsFromCall(initializer, sourceText),
+				objectType
+			};
+		}
+		if (Node.isObjectLiteralExpression(initializer)) return {
+			name,
+			fields: initializer.getProperties().map((prop) => extractFieldFromProperty(prop, sourceText)).filter((field) => field !== null),
+			objectType
+		};
+		return {
+			name,
+			fields: [],
+			objectType
+		};
+	};
+}
+/**
+* Extracts schemas from TypeScript source code using AST analysis.
+*
+* This function processes exported variable declarations to extract table schemas
+* with their field definitions and comments. It supports both Zod and Valibot schema extraction.
+*
+* @param lines - Array of source code lines to process
+* @param library - The validation library to extract schemas for ('zod' or 'valibot')
+* @returns Array of extracted schemas with field definitions
+*
+* @example
+* ```typescript
+* // For Zod schemas
+* const zodSchemas = extractSchemas(sourceLines, 'zod')
+*
+* // For Valibot schemas
+* const valibotSchemas = extractSchemas(sourceLines, 'valibot')
+* ```
+*/
+function extractSchemas(lines, library) {
+	const sourceCode = lines.join("\n");
+	const sourceFile = new Project({
+		useInMemoryFileSystem: true,
+		compilerOptions: {
+			allowJs: true,
+			skipLibCheck: true
+		}
+	}).createSourceFile("temp.ts", sourceCode);
+	const sourceText = sourceFile.getFullText();
+	const commentPrefix = library === "zod" ? "@z." : library === "valibot" ? "@v." : library === "arktype" ? "@a." : "@e.";
+	const schemaPrefix = library === "zod" ? "z" : library === "valibot" ? "v" : library === "arktype" ? "type" : "Schema";
+	const extractField = createExtractFieldFromProperty((lines) => parseFieldComments(lines, commentPrefix));
+	const extractSchema = buildSchemaExtractor(createExtractFieldsFromCallExpression(extractField, createExtractRelationFieldFromProperty((lines) => parseFieldComments(lines, commentPrefix), schemaPrefix), findObjectLiteralExpression, findObjectLiteralInArgs, isRelationFunctionCall), extractField, parseFieldComments, commentPrefix);
+	return sourceFile.getVariableStatements().filter((stmt) => stmt.hasExportKeyword()).map((stmt) => extractSchema(stmt, sourceText, sourceCode)).filter((schema) => schema !== null);
+}
+/**
+* Extracts relation schemas from `relations(...)` declarations using AST analysis.
+*
+* This returns entries like `userRelations` and `postRelations` with fields
+* resolved to either `z.array(OtherSchema)` / `v.array(OtherSchema)` or direct
+* `OtherSchema` based on `many`/`one`.
+*
+* Note: Base table schemas are not included here; use `extractSchemas` for those.
+*/
+function extractRelationSchemas(lines, library) {
+	const sourceCode = lines.join("\n");
+	const sourceFile = new Project({
+		useInMemoryFileSystem: true,
+		compilerOptions: {
+			allowJs: true,
+			skipLibCheck: true
+		}
+	}).createSourceFile("temp.ts", sourceCode);
+	const sourceText = sourceFile.getFullText();
+	const commentPrefix = library === "zod" ? "@z." : library === "valibot" ? "@v." : library === "arktype" ? "@a." : "@e.";
+	const schemaPrefix = library === "zod" ? "z" : library === "valibot" ? "v" : library === "arktype" ? "type" : "Schema";
+	const baseSchemas = extractSchemas(lines, library);
+	const baseSchemaMap = new Map(baseSchemas.map((schema) => [schema.name, schema.objectType]));
+	const extractFieldsFromCall = createExtractFieldsFromCallExpression(createExtractFieldFromProperty((lines) => parseFieldComments(lines, commentPrefix)), createExtractRelationFieldFromProperty((lines) => parseFieldComments(lines, commentPrefix), schemaPrefix), findObjectLiteralExpression, findObjectLiteralInArgs, isRelationFunctionCall);
+	function extract(declaration) {
+		if (!Node.isVariableDeclaration(declaration)) return null;
+		const name = declaration.getName();
+		if (!name) return null;
+		const initializer = declaration.getInitializer();
+		if (!Node.isCallExpression(initializer)) return null;
+		if (!isRelationFunctionCall(initializer)) return null;
+		const relArgs = initializer.getArguments();
+		const baseIdentifier = relArgs.length && Node.isIdentifier(relArgs[0]) ? relArgs[0] : void 0;
+		if (!baseIdentifier) return null;
+		const baseName = baseIdentifier.getText();
+		return {
+			name,
+			baseName,
+			fields: extractFieldsFromCall(initializer, sourceText),
+			objectType: baseSchemaMap.get(baseName)
+		};
+	}
+	return sourceFile.getVariableStatements().filter((stmt) => stmt.hasExportKeyword()).flatMap((stmt) => stmt.getDeclarations()).map((decl) => extract(decl)).filter((schema) => schema !== null);
+}
+
+//#endregion
+//#region src/generator/arktype/generator/arktype.ts
+/**
+* Generates an ArkType schema for a given schema and config.
+*
+* @param schema - The schema to generate code for.
+* @param comment - Whether to include comments in the generated code.
+* @returns The generated ArkType schema.
+*/
+function arktype(schema, comment) {
+	const inner = fieldDefinitions(schema, comment);
+	return `export const ${makeCapitalized(schema.name)}Schema = type({${inner}})`;
+}
+
+//#endregion
+//#region src/generator/arktype/generator/arktype-code.ts
+/**
+* Generates ArkType code for a given schema and config.
+*
+* @param schema - The schema to generate code for.
+* @param comment - Whether to include comments in the generated code.
+* @param type - Whether to include type information in the generated code.
+* @returns The generated ArkType code.
+*/
+function arktypeCode(schema, comment, type) {
+	const arktypeSchema = arktype(schema, comment);
+	if (type) return `${arktypeSchema}\n\n${inferArktype(schema.name)}\n`;
+	return `${arktypeSchema}\n`;
+}
+
+//#endregion
+//#region src/generator/arktype/index.ts
+/**
+* Generate ArkType schema
+* @param code - The code to generate ArkType schema from
+* @param output - The output file path
+* @param comment - Whether to include comments in the generated code
+* @param type - Whether to include type information in the generated code
+*/
+async function sizukuArktype(code, output, comment, type) {
+	const arktypeGeneratedCode = [
+		`import { type } from 'arktype'`,
+		"",
+		...extractSchemas(code, "arktype").map((schema) => arktypeCode(schema, comment ?? false, type ?? false))
+	].join("\n");
+	const mkdirResult = await mkdir(path.dirname(output));
+	if (!mkdirResult.ok) return {
+		ok: false,
+		error: mkdirResult.error
+	};
+	const fmtResult = await fmt(arktypeGeneratedCode);
+	if (!fmtResult.ok) return {
+		ok: false,
+		error: fmtResult.error
+	};
+	const writeFileResult = await writeFile(output, fmtResult.value);
+	if (!writeFileResult.ok) return {
+		ok: false,
+		error: writeFileResult.error
+	};
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+
+//#endregion
+//#region src/generator/mermaid-er/validator/index.ts
+/**
+* Create a unique key for relation deduplication.
+*/
+function relationKey(r) {
+	return `${r.fromModel}.${r.fromField}->${r.toModel}.${r.toField}`;
+}
+/**
+* Extract base builder name from expression.
+*
+* @param expr - The expression to extract name from
+* @returns The base builder name
+*/
+function baseBuilderName(expr) {
+	if (Node.isIdentifier(expr)) return expr.getText();
+	if (Node.isCallExpression(expr) || Node.isPropertyAccessExpression(expr)) return baseBuilderName(expr.getExpression());
+	return "";
+}
+/**
+* Type guard for FieldInfo.
+*
+* @param v - The value to check
+* @returns True if value is FieldInfo
+*/
+function isFieldInfo(v) {
+	return v !== null;
+}
+/**
+* Extract key type based on field definition.
+*
+* @param initText - The initializer text
+* @returns The key type (PK, FK, or null)
+*/
+function extractKeyType(initText) {
+	if (initText.includes(".primaryKey()")) return "PK";
+	if (initText.includes(".references(")) return "FK";
+	return null;
+}
+/**
+* Find immediate comment for a field.
+*
+* @param code - The source code lines
+* @param lineIdx - The line index of the field
+* @returns The immediate comment or empty string
+*/
+function findImmediateComment(code, lineIdx) {
+	return code.slice(0, lineIdx).reverse().find((line) => {
+		const t = line.trim();
+		return t.startsWith("///") && !t.includes("@z.") && !t.includes("@v.") && !t.includes("@a.") && !t.includes("@e.") && !t.includes("@relation");
+	})?.replace(/^\s*\/\/\/\s*/, "") ?? "";
+}
+/**
+* Extract reference info from a .references() call.
+*
+* @param initExpr - The call expression to analyze
+* @returns The reference info or null
+*/
+function extractReferenceInfo(initExpr) {
+	const match = initExpr.getText().match(/\.references\(\s*\(\)\s*=>\s*(\w+)\.(\w+)\s*\)/);
+	if (match) return {
+		referencedTable: match[1],
+		referencedField: match[2]
+	};
+	return null;
+}
+/**
+* Check if field is required (notNull).
+*
+* @param initText - The initializer text
+* @returns True if field is required
+*/
+function isFieldRequired(initText) {
+	return initText.includes(".notNull()");
+}
+/**
+* Extract field info from property assignment.
+*
+* @param prop - The property assignment node
+* @param code - The source code lines
+* @returns Field info or null
+*/
+function extractFieldInfo(prop, code) {
+	const keyNode = prop.getNameNode();
+	if (!Node.isIdentifier(keyNode)) return null;
+	const fieldName = keyNode.getText();
+	const initExpr = prop.getInitializer();
+	if (!(initExpr && Node.isCallExpression(initExpr))) return null;
+	const fieldType = baseBuilderName(initExpr);
+	const initText = initExpr.getText();
+	const immediateComment = findImmediateComment(code, prop.getStartLineNumber() - 1);
+	return {
+		name: fieldName,
+		type: fieldType,
+		keyType: extractKeyType(initText),
+		description: immediateComment || null
+	};
+}
+/**
+* Extract relation info from a property assignment with .references().
+*
+* @param prop - The property assignment node
+* @param tableName - The name of the current table
+* @returns Relation info or null
+*/
+function extractRelationFromField(prop, tableName) {
+	const keyNode = prop.getNameNode();
+	if (!Node.isIdentifier(keyNode)) return null;
+	const fieldName = keyNode.getText();
+	const initExpr = prop.getInitializer();
+	if (!(initExpr && Node.isCallExpression(initExpr))) return null;
+	const initText = initExpr.getText();
+	if (!initText.includes(".references(")) return null;
+	const refInfo = extractReferenceInfo(initExpr);
+	if (!refInfo) return null;
+	const isRequired = isFieldRequired(initText);
+	return {
+		fromModel: refInfo.referencedTable,
+		toModel: tableName,
+		fromField: refInfo.referencedField,
+		toField: fieldName,
+		isRequired
+	};
+}
+/**
+* Extract relations from foreignKey() constraints in the third argument.
+*
+* Pattern:
+* foreignKey({
+*   columns: [TableName.fieldName],
+*   foreignColumns: [OtherTable.fieldName],
+* })
+*
+* @param tableName - The name of the current table
+* @param constraintArg - The third argument (arrow function returning constraints object)
+* @returns Array of relation info
+*/
+function extractRelationsFromForeignKeyConstraints(tableName, constraintArg) {
+	const relations = [];
+	if (!Node.isArrowFunction(constraintArg)) return relations;
+	const body = constraintArg.getBody();
+	if (!body) return relations;
+	let objExpr = body;
+	if (Node.isParenthesizedExpression(objExpr)) objExpr = objExpr.getExpression();
+	if (!Node.isObjectLiteralExpression(objExpr)) return relations;
+	objExpr.getProperties().forEach((prop) => {
+		if (!Node.isPropertyAssignment(prop)) return;
+		const initExpr = prop.getInitializer();
+		if (!initExpr) return;
+		const text = initExpr.getText();
+		if (!text.includes("foreignKey(")) return;
+		const columnsMatch = text.match(/columns:\s*\[\s*(\w+)\.(\w+)\s*\]/);
+		const foreignColumnsMatch = text.match(/foreignColumns:\s*\[\s*(\w+)\.(\w+)\s*\]/);
+		if (columnsMatch && foreignColumnsMatch) {
+			const toField = columnsMatch[2];
+			const fromModel = foreignColumnsMatch[1];
+			const fromField = foreignColumnsMatch[2];
+			const isRequired = !text.includes(".nullable()");
+			relations.push({
+				fromModel,
+				toModel: tableName,
+				fromField,
+				toField,
+				isRequired
+			});
+		}
+	});
+	return relations;
+}
+/**
+* Extract relations from relations() helper blocks.
+*
+* Pattern:
+* relations(TableRef, ({ one, many }) => ({
+*   user: one(User, {
+*     fields: [Post.userId],
+*     references: [User.id],
+*   }),
+*   posts: many(Post),
+* }))
+*
+* @param file - The source file
+* @returns Array of relation info
+*/
+function extractRelationsFromRelationBlocks(file) {
+	const relations = [];
+	file.getVariableStatements().filter((stmt) => stmt.isExported()).forEach((stmt) => {
+		const decl = stmt.getDeclarations()[0];
+		if (!Node.isVariableDeclaration(decl)) return;
+		if (!decl.getName().toLowerCase().includes("relation")) return;
+		const init = decl.getInitializer();
+		if (!(init && Node.isCallExpression(init))) return;
+		if (init.getExpression().getText() !== "relations") return;
+		const args = init.getArguments();
+		if (args.length < 2) return;
+		const tableRef = args[0];
+		if (!Node.isIdentifier(tableRef)) return;
+		const tableName = tableRef.getText();
+		const arrowFn = args[1];
+		if (!Node.isArrowFunction(arrowFn)) return;
+		const body = arrowFn.getBody();
+		if (!body) return;
+		let objExpr = body;
+		if (Node.isParenthesizedExpression(objExpr)) objExpr = objExpr.getExpression();
+		if (!Node.isObjectLiteralExpression(objExpr)) return;
+		objExpr.getProperties().forEach((prop) => {
+			if (!Node.isPropertyAssignment(prop)) return;
+			const initExpr = prop.getInitializer();
+			if (!(initExpr && Node.isCallExpression(initExpr))) return;
+			if (initExpr.getExpression().getText() !== "one") return;
+			const relArgs = initExpr.getArguments();
+			if (relArgs.length < 2) return;
+			const refTableArg = relArgs[0];
+			if (!Node.isIdentifier(refTableArg)) return;
+			const refTable = refTableArg.getText();
+			const configArg = relArgs[1];
+			if (!Node.isObjectLiteralExpression(configArg)) return;
+			const configText = configArg.getText();
+			const fieldsMatch = configText.match(/fields:\s*\[\s*(\w+)\.(\w+)\s*\]/);
+			const referencesMatch = configText.match(/references:\s*\[\s*(\w+)\.(\w+)\s*\]/);
+			if (fieldsMatch && referencesMatch) {
+				const currentField = fieldsMatch[2];
+				const refField = referencesMatch[2];
+				const currentFieldLower = currentField.toLowerCase();
+				const refFieldLower = refField.toLowerCase();
+				const isCurrentFieldFk = currentFieldLower.endsWith("id") && currentFieldLower !== "id" || currentFieldLower.endsWith("_id");
+				const isRefFieldFk = refFieldLower.endsWith("id") && refFieldLower !== "id" || refFieldLower.endsWith("_id");
+				if (isCurrentFieldFk && !isRefFieldFk) relations.push({
+					fromModel: refTable,
+					toModel: tableName,
+					fromField: refField,
+					toField: currentField,
+					isRequired: true
+				});
+				else if (!isCurrentFieldFk && isRefFieldFk) relations.push({
+					fromModel: tableName,
+					toModel: refTable,
+					fromField: currentField,
+					toField: refField,
+					isRequired: true
+				});
+				else relations.push({
+					fromModel: refTable,
+					toModel: tableName,
+					fromField: refField,
+					toField: currentField,
+					isRequired: true
+				});
+			}
+		});
+	});
+	return relations;
+}
+/**
+* Parse table information from Drizzle schema code.
+*
+* @param code - Array of source code lines
+* @returns Array of table information
+*/
+function parseTableInfo(code) {
+	const source = code.join("\n");
+	return new Project({ useInMemoryFileSystem: true }).createSourceFile("temp.ts", source).getVariableStatements().filter((stmt) => stmt.isExported()).flatMap((stmt) => {
+		const decl = stmt.getDeclarations()[0];
+		if (!Node.isVariableDeclaration(decl)) return [];
+		const varName = decl.getName();
+		if (varName.toLowerCase().includes("relation")) return [];
+		const init = decl.getInitializer();
+		if (!(init && Node.isCallExpression(init))) return [];
+		const callee = init.getExpression().getText();
+		if (!callee.endsWith("Table") || callee === "relations") return [];
+		const objLit = init.getArguments()[1];
+		if (!(objLit && Node.isObjectLiteralExpression(objLit))) return [];
+		return [{
+			name: varName,
+			fields: objLit.getProperties().filter(Node.isPropertyAssignment).map((prop) => extractFieldInfo(prop, code)).filter(isFieldInfo)
+		}];
+	});
+}
+/**
+* Extract relations from Drizzle schema code by analyzing:
+* 1. .references() calls on fields
+* 2. foreignKey() constraints in table definition
+* 3. relations() helper blocks
+*
+* @param code - Array of source code lines
+* @returns Array of relation information (deduplicated)
+*/
+function extractRelationsFromSchema(code) {
+	const source = code.join("\n");
+	const file = new Project({ useInMemoryFileSystem: true }).createSourceFile("temp.ts", source);
+	const relations = [];
+	file.getVariableStatements().filter((stmt) => stmt.isExported()).forEach((stmt) => {
+		const decl = stmt.getDeclarations()[0];
+		if (!Node.isVariableDeclaration(decl)) return;
+		const varName = decl.getName();
+		if (varName.toLowerCase().includes("relation")) return;
+		const init = decl.getInitializer();
+		if (!(init && Node.isCallExpression(init))) return;
+		const callee = init.getExpression().getText();
+		if (!callee.endsWith("Table") || callee === "relations") return;
+		const args = init.getArguments();
+		const objLit = args[1];
+		if (objLit && Node.isObjectLiteralExpression(objLit)) objLit.getProperties().filter(Node.isPropertyAssignment).forEach((prop) => {
+			const relation = extractRelationFromField(prop, varName);
+			if (relation) relations.push(relation);
+		});
+		const constraintArg = args[2];
+		if (constraintArg && Node.isExpression(constraintArg)) {
+			const fkRelations = extractRelationsFromForeignKeyConstraints(varName, constraintArg);
+			relations.push(...fkRelations);
+		}
+	});
+	const relationBlockRelations = extractRelationsFromRelationBlocks(file);
+	relations.push(...relationBlockRelations);
+	const seen = /* @__PURE__ */ new Set();
+	return relations.filter((r) => {
+		const key = relationKey(r);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+
+//#endregion
+//#region src/generator/dbml/generator/dbml-content.ts
+/**
+* DBML content generator for Drizzle schemas
+*
+* Generates DBML (Database Markup Language) format from parsed table and relation info.
+* Uses utils-lab for common DBML generation functions.
+*/
+/**
+* Convert internal FieldInfo to DBMLColumn
+*/
+function toDBMLColumn(field) {
+	return {
+		name: field.name,
+		type: mapDrizzleType(field.type),
+		isPrimaryKey: field.keyType === "PK",
+		isIncrement: field.type.includes("serial"),
+		note: field.description ?? void 0
+	};
+}
+/**
+* Convert internal TableInfo to DBMLTable
+*/
+function toDBMLTable(table) {
+	return {
+		name: table.name,
+		columns: table.fields.map(toDBMLColumn)
+	};
+}
+/**
+* Convert internal RelationInfo to DBMLRef
+*/
+function toDBMLRef(relation) {
+	return {
+		fromTable: relation.toModel,
+		fromColumn: relation.toField,
+		toTable: relation.fromModel,
+		toColumn: relation.fromField
+	};
+}
+/**
+* Generate complete DBML content
+*
+* @param relations - The relations extracted from the schema
+* @param tables - The tables to generate DBML from
+* @returns The generated DBML content
+*/
+function dbmlContent(relations, tables) {
+	return generateDBMLContent({
+		tables: tables.map(toDBMLTable),
+		refs: relations.map(toDBMLRef)
+	});
+}
+
+//#endregion
+//#region src/generator/dbml/index.ts
+/**
+* Generate DBML schema from Drizzle schema code
+*
+* @param code - The code to generate DBML from
+* @param output - The output file path
+*/
+async function sizukuDBML(code, output) {
+	const tables = parseTableInfo(code);
+	const content = dbmlContent(extractRelationsFromSchema(code), tables);
+	const mkdirResult = await mkdir(path.dirname(output));
+	if (!mkdirResult.ok) return {
+		ok: false,
+		error: mkdirResult.error
+	};
+	const writeFileResult = await writeFile(output, content);
+	if (!writeFileResult.ok) return {
+		ok: false,
+		error: writeFileResult.error
+	};
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+
+//#endregion
+//#region src/generator/effect/generator/effect.ts
+/**
+* Generates an Effect schema for a given schema and config.
+*
+* @param schema - The schema to generate code for.
+* @param comment - Whether to include comments in the generated code.
+* @returns The generated Effect schema.
+*/
+function effect(schema, comment) {
+	const inner = fieldDefinitions(schema, comment);
+	return `export const ${makeCapitalized(schema.name)}Schema = Schema.Struct({${inner}})`;
+}
+
+//#endregion
+//#region src/generator/effect/generator/effect-code.ts
+/**
+* Generates Effect code for a given schema and config.
+*
+* @param schema - The schema to generate code for.
+* @param comment - Whether to include comments in the generated code.
+* @param type - Whether to include type information in the generated code.
+* @returns The generated Effect code.
+*/
+function effectCode(schema, comment, type) {
+	const effectSchema = effect(schema, comment);
+	if (type) return `${effectSchema}\n\n${inferEffect(schema.name)}\n`;
+	return `${effectSchema}\n`;
+}
+
+//#endregion
+//#region src/generator/effect/index.ts
+/**
+* Generate Effect schema
+* @param code - The code to generate Effect schema from
+* @param output - The output file path
+* @param comment - Whether to include comments in the generated code
+* @param type - Whether to include type information in the generated code
+*/
+async function sizukuEffect(code, output, comment, type) {
+	const effectGeneratedCode = [
+		`import { Schema } from 'effect'`,
+		"",
+		...extractSchemas(code, "effect").map((schema) => effectCode(schema, comment ?? false, type ?? false))
+	].join("\n");
+	const mkdirResult = await mkdir(path.dirname(output));
+	if (!mkdirResult.ok) return {
+		ok: false,
+		error: mkdirResult.error
+	};
+	const fmtResult = await fmt(effectGeneratedCode);
+	if (!fmtResult.ok) return {
+		ok: false,
+		error: fmtResult.error
+	};
+	const writeFileResult = await writeFile(output, fmtResult.value);
+	if (!writeFileResult.ok) return {
+		ok: false,
+		error: writeFileResult.error
+	};
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+
+//#endregion
+//#region src/generator/mermaid-er/generator/er-content.ts
+const ER_HEADER = ["```mermaid", "erDiagram"];
+const ER_FOOTER = ["```"];
+const RELATIONSHIPS = {
+	"zero-one": "|o",
+	one: "||",
+	"zero-many": "}o",
+	many: "}|"
+};
+/**
+* Generate relation line from relation info.
+*
+* @param relation - The relation info
+* @returns The Mermaid ER relation line
+*/
+function generateRelationLine(relation) {
+	const fromSymbol = RELATIONSHIPS.one;
+	const toSymbol = relation.isRequired ? RELATIONSHIPS.many : RELATIONSHIPS["zero-many"];
+	return `    ${relation.fromModel} ${fromSymbol}--${toSymbol} ${relation.toModel} : "(${relation.fromField}) - (${relation.toField})"`;
+}
+/**
+* Remove duplicate relations.
+*
+* @param relations - The relations to deduplicate
+* @returns The deduplicated relations
+*/
+function removeDuplicateRelations(relations) {
+	return [...new Set(relations)];
+}
+/**
+* Generate ER content
+* @param relations - The relations extracted from .references() calls
+* @param tables - The tables to generate the ER content from
+* @returns The generated ER content
+*/
+function erContent(relations, tables) {
+	const relationLines = removeDuplicateRelations(relations.map(generateRelationLine));
+	const tableDefinitions = tables.flatMap((table) => [
+		`    ${table.name} {`,
+		...table.fields.map((field) => {
+			const keyPart = field.keyType ? ` ${field.keyType}` : "";
+			const descPart = field.description ? ` "${field.description}"` : "";
+			return `        ${field.type} ${field.name}${keyPart}${descPart}`;
+		}),
+		"    }"
+	]);
+	return [
+		...ER_HEADER,
+		...relationLines,
+		...tableDefinitions,
+		...ER_FOOTER
+	].join("\n");
+}
+
+//#endregion
+//#region src/generator/mermaid-er/index.ts
+/**
+* Generate Mermaid ER diagram
+* @param code - The code to generate Mermaid ER diagram from
+* @param output - The output file path
+*/
+async function sizukuMermaidER(code, output) {
+	const tables = parseTableInfo(code);
+	const ERContent = erContent(extractRelationsFromSchema(code), tables);
+	const mkdirResult = await mkdir(path.dirname(output));
+	if (!mkdirResult.ok) return {
+		ok: false,
+		error: mkdirResult.error
+	};
+	const writeFileResult = await writeFile(output, ERContent);
+	if (!writeFileResult.ok) return {
+		ok: false,
+		error: writeFileResult.error
+	};
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+
+//#endregion
+//#region src/generator/svg/index.ts
+/**
+* Generate diagram from Drizzle schema code
+*
+* @param code - The code to generate diagram from
+* @param output - The output file path
+* @param format - Output format ('svg', 'png', or 'dot')
+*/
+async function sizukuSVG(code, output, format = "png") {
+	const tables = parseTableInfo(code);
+	const dbml = dbmlContent(extractRelationsFromSchema(code), tables);
+	const mkdirResult = await mkdir(path.dirname(output));
+	if (!mkdirResult.ok) return {
+		ok: false,
+		error: mkdirResult.error
+	};
+	if (format === "dot") {
+		const writeResult = await writeFile(output, run(dbml, "dot"));
+		if (!writeResult.ok) return {
+			ok: false,
+			error: writeResult.error
+		};
+	} else {
+		const svg = run(dbml, "svg");
+		if (format === "png") {
+			const writeResult = await writeFileBinary(output, new Resvg(svg, { font: { loadSystemFonts: true } }).render().asPng());
+			if (!writeResult.ok) return {
+				ok: false,
+				error: writeResult.error
+			};
+		} else {
+			const writeResult = await writeFile(output, svg);
+			if (!writeResult.ok) return {
+				ok: false,
+				error: writeResult.error
+			};
+		}
+	}
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+
+//#endregion
+//#region src/generator/valibot/generator/relation-valibot-code.ts
+/**
+* Generates Valibot relation schema code from a relation schema AST extraction.
+*
+* @param schema - The relation schema to generate code for.
+* @param withType - Whether to include type definition.
+* @returns The generated Valibot relation schema code.
+*/
+function relationValibotCode(schema, withType) {
+	const base = schema.baseName;
+	const relName = `${schema.name}Schema`;
+	const baseSchema = `${makeCapitalized$1(base)}Schema`;
+	const fields = schema.fields.map((f) => `${f.name}:${f.definition}`).join(",");
+	const objectType = schema.objectType === "strict" ? "strictObject" : schema.objectType === "loose" ? "looseObject" : "object";
+	const obj = `\nexport const ${makeCapitalized$1(relName)} = v.${objectType}({...${baseSchema}.entries,${fields}})`;
+	if (withType) return `${obj}\n\n${inferInput(schema.name)}\n`;
+	return `${obj}`;
+}
+
+//#endregion
+//#region src/generator/valibot/generator/valibot.ts
+/**
+* Generates a Valibot schema for a given schema and config.
+*
+* @param schema - The schema to generate code for.
+* @param comment - Whether to include comments in the generated code.
+* @returns The generated Valibot schema.
+*/
+function valibot(schema, comment) {
+	const wrapperType = schema.objectType === "strict" ? "strictObject" : schema.objectType === "loose" ? "looseObject" : "object";
+	const objectCode = makeValibotObject(fieldDefinitions(schema, comment), wrapperType);
+	return `export const ${makeCapitalized(schema.name)}Schema = ${objectCode}`;
+}
+
+//#endregion
+//#region src/generator/valibot/generator/valibot-code.ts
+/**
+* Generates Valibot code for a given schema and config.
+*
+* @param schema - The schema to generate code for.
+* @param comment - Whether to include comments in the generated code.
+* @param type - Whether to include type information in the generated code.
+* @returns The generated Valibot code.
+*/
+function valibotCode(schema, comment, type) {
+	const valibotSchema = valibot(schema, comment);
+	if (type) return `${valibotSchema}\n\n${inferInput(schema.name)}\n`;
+	return `${valibotSchema}\n`;
+}
+
+//#endregion
+//#region src/generator/valibot/index.ts
+/**
+* Generate Valibot schema
+* @param code - The code to generate Valibot schema from
+* @param output - The output file path
+* @param comment - Whether to include comments in the generated code
+* @param type - Whether to include type information in the generated code
+*/
+async function sizukuValibot(code, output, comment, type, relation) {
+	const baseSchemas = extractSchemas(code, "valibot");
+	const relationSchemas = extractRelationSchemas(code, "valibot");
+	const valibotGeneratedCode = [
+		"import * as v from 'valibot'",
+		"",
+		...baseSchemas.map((schema) => valibotCode(schema, comment ?? false, type ?? false)),
+		...relation ? relationSchemas.map((schema) => relationValibotCode(schema, type ?? false)) : []
+	].join("\n");
+	const mkdirResult = await mkdir(path.dirname(output));
+	if (!mkdirResult.ok) return {
+		ok: false,
+		error: mkdirResult.error
+	};
+	const fmtResult = await fmt(valibotGeneratedCode);
+	if (!fmtResult.ok) return {
+		ok: false,
+		error: fmtResult.error
+	};
+	const writeFileResult = await writeFile(output, fmtResult.value);
+	if (!writeFileResult.ok) return {
+		ok: false,
+		error: writeFileResult.error
+	};
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+
+//#endregion
+//#region src/generator/zod/generator/relation-zod-code.ts
+/**
+* Generates Zod relation schema code from a relation schema AST extraction.
+*
+* @param schema - The relation schema to generate code for.
+* @param withType - Whether to include type definition.
+* @returns The generated Zod relation schema code.
+*/
+function relationZodCode(schema, withType) {
+	const base = schema.baseName;
+	const relName = `${schema.name}Schema`;
+	const baseSchema = `${makeCapitalized$1(base)}Schema`;
+	const fields = schema.fields.map((f) => `${f.name}:${f.definition}`).join(",");
+	const objectType = schema.objectType === "strict" ? "strictObject" : schema.objectType === "loose" ? "looseObject" : "object";
+	const obj = `\nexport const ${makeCapitalized$1(relName)} = z.${objectType}({...${baseSchema}.shape,${fields}})`;
+	if (withType) return `${obj}\n\n${infer(schema.name)}\n`;
+	return `${obj}`;
+}
+
+//#endregion
+//#region src/generator/zod/generator/zod.ts
+/**
+* Generates a Zod schema for a given schema and config.
+*
+* @param schema - The schema to generate code for.
+* @param comment - Whether to include comments in the generated code.
+* @returns The generated Zod schema.
+*/
+function zod(schema, comment) {
+	const wrapperType = schema.objectType === "strict" ? "strictObject" : schema.objectType === "loose" ? "looseObject" : "object";
+	const objectCode = makeZodObject(fieldDefinitions(schema, comment), wrapperType);
+	return `export const ${makeCapitalized(schema.name)}Schema = ${objectCode}`;
+}
+
+//#endregion
+//#region src/generator/zod/generator/zod-code.ts
+/**
+* Generates Zod code for a given schema and config.
+*
+* @param schema - The schema to generate code for.
+* @param comment - Whether to include comments in the generated code.
+* @param type - Whether to include type information in the generated code.
+* @returns The generated Zod code.
+*/
+function zodCode(schema, comment, type) {
+	const zodSchema = zod(schema, comment);
+	if (type) return `${zodSchema}\n\n${infer(schema.name)}\n`;
+	return `${zodSchema}\n`;
+}
+
+//#endregion
+//#region src/generator/zod/index.ts
+/**
+* Generate Zod schema
+* @param code - The code to generate Zod schema from
+* @param output - The output file path
+* @param comment - Whether to include comments in the generated code
+* @param type - Whether to include type information in the generated code
+* @param zod - The Zod version to use
+*/
+async function sizukuZod(code, output, comment, type, zod, relation) {
+	const importLine = zod === "mini" ? `import * as z from 'zod/mini'` : zod === "@hono/zod-openapi" ? `import { z } from '@hono/zod-openapi'` : `import * as z from 'zod'`;
+	const baseSchemas = extractSchemas(code, "zod");
+	const relationSchemas = extractRelationSchemas(code, "zod");
+	const zodGeneratedCode = [
+		importLine,
+		"",
+		...baseSchemas.map((schema) => zodCode(schema, comment ?? false, type ?? false)),
+		...relation ? relationSchemas.map((schema) => relationZodCode(schema, type ?? false)) : []
+	].join("\n");
+	const mkdirResult = await mkdir(path.dirname(output));
+	if (!mkdirResult.ok) return {
+		ok: false,
+		error: mkdirResult.error
+	};
+	const fmtResult = await fmt(zodGeneratedCode);
+	if (!fmtResult.ok) return {
+		ok: false,
+		error: fmtResult.error
+	};
+	const writeFileResult = await writeFile(output, fmtResult.value);
+	if (!writeFileResult.ok) return {
+		ok: false,
+		error: writeFileResult.error
+	};
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+
+//#endregion
+//#region src/shared/fs/index.ts
+function readFileSync(path) {
+	try {
+		return {
+			ok: true,
+			value: fs.readFileSync(path, "utf-8")
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+
+//#endregion
+//#region src/index.ts
+async function main() {
+	const configResult = await config();
+	if (!configResult.ok) return {
+		ok: false,
+		error: configResult.error
+	};
+	const c = configResult.value;
+	const contentResult = readFileSync(c.input);
+	if (!contentResult.ok) return {
+		ok: false,
+		error: contentResult.error
+	};
+	const lines = contentResult.value.split("\n");
+	const codeStart = lines.findIndex((line) => !line.trim().startsWith("import") && line.trim() !== "");
+	const code = lines.slice(codeStart);
+	const zodMessage = c.zod?.output ? await (async () => {
+		const zodConfig = c.zod;
+		if (!zodConfig?.output) return {
+			ok: false,
+			error: "Zod config is missing"
+		};
+		const zodResult = await sizukuZod(code, zodConfig.output, zodConfig.comment, zodConfig.type, zodConfig.zod, zodConfig.relation);
+		if (!zodResult.ok) return {
+			ok: false,
+			error: zodResult.error
+		};
+		return {
+			ok: true,
+			value: `Generated Zod schema at: ${zodConfig.output}`
+		};
+	})() : null;
+	if (zodMessage && !zodMessage.ok) return {
+		ok: false,
+		error: zodMessage.error
+	};
+	const valibotMessage = c.valibot?.output ? await (async () => {
+		const valibotConfig = c.valibot;
+		if (!valibotConfig?.output) return {
+			ok: false,
+			error: "Valibot config is missing"
+		};
+		const valibotResult = await sizukuValibot(code, valibotConfig.output, valibotConfig.comment, valibotConfig.type, valibotConfig.relation);
+		if (!valibotResult.ok) return {
+			ok: false,
+			error: valibotResult.error
+		};
+		return {
+			ok: true,
+			value: `Generated Valibot schema at: ${valibotConfig.output}`
+		};
+	})() : null;
+	if (valibotMessage && !valibotMessage.ok) return {
+		ok: false,
+		error: valibotMessage.error
+	};
+	const arktypeMessage = c.arktype?.output ? await (async () => {
+		const arktypeConfig = c.arktype;
+		if (!arktypeConfig?.output) return {
+			ok: false,
+			error: "ArkType config is missing"
+		};
+		const arktypeResult = await sizukuArktype(code, arktypeConfig.output, arktypeConfig.comment, arktypeConfig.type);
+		if (!arktypeResult.ok) return {
+			ok: false,
+			error: arktypeResult.error
+		};
+		return {
+			ok: true,
+			value: `Generated ArkType schema at: ${arktypeConfig.output}`
+		};
+	})() : null;
+	if (arktypeMessage && !arktypeMessage.ok) return {
+		ok: false,
+		error: arktypeMessage.error
+	};
+	const effectMessage = c.effect?.output ? await (async () => {
+		const effectConfig = c.effect;
+		if (!effectConfig?.output) return {
+			ok: false,
+			error: "Effect config is missing"
+		};
+		const effectResult = await sizukuEffect(code, effectConfig.output, effectConfig.comment, effectConfig.type);
+		if (!effectResult.ok) return {
+			ok: false,
+			error: effectResult.error
+		};
+		return {
+			ok: true,
+			value: `Generated Effect schema at: ${effectConfig.output}`
+		};
+	})() : null;
+	if (effectMessage && !effectMessage.ok) return {
+		ok: false,
+		error: effectMessage.error
+	};
+	const mermaidMessage = c.mermaid?.output ? await (async () => {
+		const mermaidConfig = c.mermaid;
+		if (!mermaidConfig?.output) return {
+			ok: false,
+			error: "Mermaid config is missing"
+		};
+		const mermaidResult = await sizukuMermaidER(code, mermaidConfig.output);
+		if (!mermaidResult.ok) return {
+			ok: false,
+			error: mermaidResult.error
+		};
+		return {
+			ok: true,
+			value: `Generated Mermaid ER at: ${mermaidConfig.output}`
+		};
+	})() : null;
+	if (mermaidMessage && !mermaidMessage.ok) return {
+		ok: false,
+		error: mermaidMessage.error
+	};
+	const dbmlMessage = c.dbml?.output ? await (async () => {
+		const dbmlConfig = c.dbml;
+		if (!dbmlConfig?.output) return {
+			ok: false,
+			error: "DBML config is missing"
+		};
+		const dbmlResult = await sizukuDBML(code, dbmlConfig.output);
+		if (!dbmlResult.ok) return {
+			ok: false,
+			error: dbmlResult.error
+		};
+		return {
+			ok: true,
+			value: `Generated DBML schema at: ${dbmlConfig.output}`
+		};
+	})() : null;
+	if (dbmlMessage && !dbmlMessage.ok) return {
+		ok: false,
+		error: dbmlMessage.error
+	};
+	const svgMessage = c.svg?.output ? await (async () => {
+		const svgConfig = c.svg;
+		if (!svgConfig?.output) return {
+			ok: false,
+			error: "SVG config is missing"
+		};
+		const svgResult = await sizukuSVG(code, svgConfig.output, svgConfig.format);
+		if (!svgResult.ok) return {
+			ok: false,
+			error: svgResult.error
+		};
+		return {
+			ok: true,
+			value: `Generated SVG diagram at: ${svgConfig.output}`
+		};
+	})() : null;
+	if (svgMessage && !svgMessage.ok) return {
+		ok: false,
+		error: svgMessage.error
+	};
+	return {
+		ok: true,
+		value: [
+			zodMessage?.ok ? zodMessage.value : null,
+			valibotMessage?.ok ? valibotMessage.value : null,
+			arktypeMessage?.ok ? arktypeMessage.value : null,
+			effectMessage?.ok ? effectMessage.value : null,
+			mermaidMessage?.ok ? mermaidMessage.value : null,
+			dbmlMessage?.ok ? dbmlMessage.value : null,
+			svgMessage?.ok ? svgMessage.value : null
+		].filter((msg) => msg !== null).join("\n")
+	};
+}
+main().then((result) => {
+	if (result?.ok) console.log(result.value);
+	else console.error(result?.error);
+});
+
+//#endregion
+export { main };