sizuku 0.6.1 → 0.6.2

package/dist/index.mjs

@@ -1,357 +1,73 @@
-import fs from "node:fs";
-import fsp from "node:fs/promises";
 import path, { dirname } from "node:path";
-import { format } from "oxfmt";
 import { Node, Project } from "ts-morph";
+import { format } from "oxfmt";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
 import { Resvg } from "@resvg/resvg-js";
 import { run } from "@softwaretechnik/dbml-renderer";
-//#region src/fsp/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)
-		};
-	}
-}
-/**
-* 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/format/index.ts
-/**
-* Format TypeScript code using oxfmt
-* @param input - The code to format
-* @returns The formatted code, or throws on format errors (I/O boundary)
-*/
-async function fmt(input) {
-	const { code, errors } = await format("<stdin>.ts", input, {
-		printWidth: 100,
-		singleQuote: true,
-		semi: false
-	});
-	if (errors.length > 0) throw new Error(errors.map((e) => e.message).join("\n"));
-	return code;
-}
-//#endregion
 //#region src/utils/index.ts
-/**
-* Capitalize the first character of a string.
-*
-* @param str - The input string.
-* @returns String with first character capitalized.
-*/
 function makeCapitalized(str) {
 	return `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
 }
-/**
-* Resolve schema object wrapper type from objectType annotation.
-*/
+function stripImports(content) {
+	const lines = content.split("\n");
+	const codeStart = lines.findIndex((line) => !line.trim().startsWith("import") && line.trim() !== "");
+	return lines.slice(codeStart);
+}
 function resolveWrapperType(objectType) {
 	if (objectType === "strict") return "strictObject";
 	if (objectType === "loose") return "looseObject";
 	return "object";
 }
-/**
-* Resolve ArkType undeclared key handling prefix.
-*
-* ArkType uses `"+"` key to control unknown property behavior:
-* - strict → `"+": "reject"` (reject unknown keys)
-* - loose → `"+": "ignore"` (preserve unknown keys, which is ArkType's default)
-* - undefined → no prefix (default behavior: preserve unknown keys)
-*/
-function resolveArktypeUndeclared(objectType) {
-	if (objectType === "strict") return "\"+\":\"reject\",";
-	if (objectType === "loose") return "\"+\":\"ignore\",";
-	return "";
-}
-/**
-* Join relation schema fields into a comma-separated string.
-*/
 function makeRelationFields(fields) {
 	return fields.map((f) => `${f.name}:${f.definition}`).join(",");
 }
-/**
-* Generates a Zod object wrapper.
-*
-* @param inner - The inner field definitions string.
-* @param wrapperType - The object wrapper type.
-* @returns The generated Zod object string.
-*/
-function makeZodObject(inner, wrapperType = "object") {
-	switch (wrapperType) {
-		case "strictObject": return `z.strictObject({${inner}})`;
-		case "looseObject": return `z.looseObject({${inner}})`;
-		default: return `z.object({${inner}})`;
-	}
-}
-/**
-* Generates a Valibot object wrapper.
-*
-* @param inner - The inner field definitions string.
-* @param wrapperType - The object wrapper type.
-* @returns The generated Valibot object string.
-*/
-function makeValibotObject(inner, wrapperType = "object") {
-	switch (wrapperType) {
-		case "strictObject": return `v.strictObject({${inner}})`;
-		case "looseObject": return `v.looseObject({${inner}})`;
-		default: return `v.object({${inner}})`;
-	}
-}
-/**
-* 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.
-*
-* @param commentLines - Raw comment lines
-* @returns Cleaned comment lines
-*/
 function cleanCommentLines(commentLines) {
 	return commentLines.map((line) => line.replace(/^\/\/\/\s*/, "").trim()).filter(Boolean);
 }
-/**
-* 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) {
+function parseFieldComments(commentLines, tag) {
+	const cleaned = cleanCommentLines(commentLines);
 	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 objectType = !objectTypeLine ? void 0 : objectTypeLine.includes("strictObject") ? "strict" : "loose";
 	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);
+	const definition = (() => {
+		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;
+	})();
+	const descriptionLines = cleaned.filter((line) => !line.includes("@z.") && !line.includes("@v.") && !line.includes("@a.") && !line.includes("@e.") && !line.includes("@relation."));
 	return {
-		definition: extractDefinition(cleaned, tag),
-		description: extractDescription(cleaned),
+		definition,
+		description: descriptionLines.length > 0 ? descriptionLines.join(" ") : void 0,
 		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.
-*
-* @param name - The model name
-* @returns The generated TypeScript type definition line using Zod.
-*/
-function infer(name) {
-	const modelName = makeCapitalized(name);
-	return `export type ${modelName} = z.infer<typeof ${modelName}Schema>`;
-}
-/**
-* Creates `v.InferOutput` type for the specified model.
-*
-* @param name - The model name
-* @returns The generated TypeScript type definition line using Valibot.
-*/
-function inferOutput(name) {
-	const modelName = makeCapitalized(name);
-	return `export type ${modelName} = v.InferOutput<typeof ${modelName}Schema>`;
-}
-/**
-* Generate a JSDoc comment block from a description
-* @param description - The description text
-* @returns The formatted JSDoc comment block
-*/
-function makeCommentBlock(description) {
-	if (!description) return "";
-	return `/**\n * ${description}\n */\n`;
+	const reversed = sourceText.substring(0, fieldStartPos).split("\n").map((l) => l.trim()).reverse();
+	const stopIdx = reversed.findIndex((l) => l !== "" && !l.startsWith("///"));
+	return (stopIdx === -1 ? reversed : reversed.slice(0, stopIdx)).filter((l) => l.startsWith("///")).reverse();
 }
-/**
-* Generate field definitions with optional JSDoc comments
-* @param schema - The schema with fields to generate definitions for
-* @param comment - Whether to include JSDoc comments
-*/
 function fieldDefinitions(schema, comment) {
 	return schema.fields.map(({ name, definition, description }) => {
-		return `${description && comment ? makeCommentBlock(description) : ""}${name}:${definition}`;
+		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}Encoded = typeof ${capitalized}Schema.Encoded`;
-}
 //#endregion
 //#region src/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 makeSourceFile(sourceCode) {
+	return new Project({
+		useInMemoryFileSystem: true,
+		compilerOptions: {
+			allowJs: true,
+			skipLibCheck: true
+		}
+	}).createSourceFile("temp.ts", sourceCode);
+}
 function generateRelationDefinition(fnName, refTable, prefix) {
 	const schema = `${makeCapitalized(refTable)}Schema`;
 	if (fnName === "many") {
@@ -362,469 +78,196 @@ function generateRelationDefinition(fnName, refTable, prefix) {
 	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());
+	if (Node.isArrowFunction(expr)) {
+		const body = expr.getBody();
+		if (Node.isObjectLiteralExpression(body)) return body;
+		if (Node.isParenthesizedExpression(body)) return findObjectLiteralExpression(body.getExpression());
+		if (Node.isBlock(body)) {
+			const re = body.getStatements().find(Node.isReturnStatement)?.getExpression();
+			return re && Node.isObjectLiteralExpression(re) ? re : null;
+		}
+	}
 	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) {
+function findObjectLiteralInArgs(call) {
 	for (const arg of call.getArguments()) {
-		const obj = finder(arg);
+		const obj = findObjectLiteralExpression(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 makeSchemaExtractor(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 = [];
-		const lineNumber = originalSourceLines.reduce((state, line, i) => state.found ? state : state.acc >= statementStart ? {
-			acc: state.acc,
-			index: i,
-			found: true
-		} : {
-			acc: state.acc + line.length + 1,
-			index: 0,
-			found: false
-		}, {
-			acc: 0,
-			index: 0,
-			found: false
-		}).index;
-		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
-		};
+	const fnName = expression.getText();
+	return fnName === "relations" || fnName.includes("relation");
+}
+function extractFieldFromProperty(property, sourceText, tag) {
+	if (!Node.isPropertyAssignment(property)) return null;
+	const name = property.getName();
+	if (!name) return null;
+	const { definition, description } = parseFieldComments(extractFieldComments(sourceText, property.getStart()), tag);
+	return {
+		name,
+		definition,
+		description
+	};
+}
+function extractRelationFieldFromProperty(property, sourceText, tag, prefix) {
+	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()), tag);
+	return {
+		name,
+		definition,
+		description
+	};
+}
+function extractFieldsFromCall(call, sourceText, tag, prefix) {
+	const objectLiteral = findObjectLiteralInArgs(call);
+	if (!objectLiteral) return [];
+	const isRelation = isRelationFunctionCall(call);
+	return objectLiteral.getProperties().map((prop) => isRelation ? extractRelationFieldFromProperty(prop, sourceText, tag, prefix) : extractFieldFromProperty(prop, sourceText, tag)).filter((f) => f !== null);
+}
+function findLeadingComments(sourceCode, statementStart) {
+	const lines = sourceCode.split("\n");
+	const lineNumber = sourceCode.slice(0, statementStart).split("\n").length - 1;
+	const reversed = lines.slice(0, lineNumber).reverse();
+	const stopIdx = reversed.findIndex((l) => l.trim() !== "" && !l.trim().startsWith("///"));
+	return (stopIdx === -1 ? reversed : reversed.slice(0, stopIdx)).filter((l) => l.trim().startsWith("///")).reverse();
+}
+function extractSchema(variableStatement, sourceText, sourceCode, tag, prefix) {
+	if (!Node.isVariableStatement(variableStatement)) return null;
+	const declaration = variableStatement.getDeclarations()[0];
+	if (!declaration) return null;
+	const name = declaration.getName();
+	if (!name) return null;
+	const { objectType } = parseFieldComments(findLeadingComments(sourceCode, variableStatement.getStart()), tag);
+	const initializer = declaration.getInitializer();
+	if (Node.isCallExpression(initializer)) {
+		if (isRelationFunctionCall(initializer)) return null;
 		return {
 			name,
-			fields: [],
+			fields: extractFieldsFromCall(initializer, sourceText, tag, prefix),
 			objectType
 		};
+	}
+	if (Node.isObjectLiteralExpression(initializer)) return {
+		name,
+		fields: initializer.getProperties().map((prop) => extractFieldFromProperty(prop, sourceText, tag)).filter((f) => f !== 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 sourceFile = makeSourceFile(sourceCode);
 	const sourceText = sourceFile.getFullText();
-	const commentPrefixMap = {
+	const tag = {
 		zod: "@z.",
 		valibot: "@v.",
 		arktype: "@a.",
 		effect: "@e."
-	};
-	const schemaPrefixMap = {
+	}[library];
+	const prefix = {
 		zod: "z",
 		valibot: "v",
 		arktype: "type",
 		effect: "Schema"
-	};
-	const commentPrefix = commentPrefixMap[library];
-	const schemaPrefix = schemaPrefixMap[library];
-	const extractField = createExtractFieldFromProperty((lines) => parseFieldComments(lines, commentPrefix));
-	const extractSchema = makeSchemaExtractor(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);
+	}[library];
+	return sourceFile.getVariableStatements().filter((stmt) => stmt.hasExportKeyword()).map((stmt) => extractSchema(stmt, sourceText, sourceCode, tag, prefix)).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 sourceFile = makeSourceFile(lines.join("\n"));
 	const sourceText = sourceFile.getFullText();
-	const commentPrefixMap = {
+	const tag = {
 		zod: "@z.",
 		valibot: "@v.",
 		arktype: "@a.",
 		effect: "@e."
-	};
-	const schemaPrefixMap = {
+	}[library];
+	const prefix = {
 		zod: "z",
 		valibot: "v",
 		arktype: "type",
 		effect: "Schema"
-	};
-	const commentPrefix = commentPrefixMap[library];
-	const schemaPrefix = schemaPrefixMap[library];
-	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) {
+	}[library];
+	const baseSchemaMap = new Map(extractSchemas(lines, library).map((schema) => [schema.name, schema.objectType]));
+	return sourceFile.getVariableStatements().filter((stmt) => stmt.hasExportKeyword()).flatMap((stmt) => stmt.getDeclarations()).map((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 baseIdentifier = initializer.getArguments()[0];
+		if (!baseIdentifier || !Node.isIdentifier(baseIdentifier)) return null;
 		const baseName = baseIdentifier.getText();
 		return {
 			name,
 			baseName,
-			fields: extractFieldsFromCall(initializer, sourceText),
+			fields: extractFieldsFromCall(initializer, sourceText, tag, prefix),
 			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/index.ts
-/**
-* Generate ArkType type() definition from a schema
-* @param schema - The schema to generate ArkType definition from
-* @param comment - Whether to include JSDoc comments in the generated code
-*/
-function arktype(schema, comment) {
-	const inner = fieldDefinitions(schema, comment);
-	const undeclared = resolveArktypeUndeclared(schema.objectType);
-	return `export const ${makeCapitalized(schema.name)}Schema = type({${undeclared}${inner}})`;
-}
-/**
-* Generate ArkType schema code with optional type inference
-* @param schema - The schema to generate code from
-* @param comment - Whether to include JSDoc comments in the generated code
-* @param type - Whether to include type inference
-*/
-function arktypeCode(schema, comment, type) {
-	const arktypeSchema = arktype(schema, comment);
-	if (type) return `${arktypeSchema}\n\n${inferArktype(schema.name)}\n`;
-	return `${arktypeSchema}\n`;
-}
-/**
-* Generate ArkType relation schema code with spread base schema
-* @param schema - The relation schema with base model reference
-* @param withType - Whether to include type inference
-*/
-function makeRelationArktypeCode(schema, withType) {
-	const relName = `${schema.name}Schema`;
-	const baseSchema = `${makeCapitalized(schema.baseName)}Schema`;
-	const fields = makeRelationFields(schema.fields);
-	const undeclared = resolveArktypeUndeclared(schema.objectType);
-	const obj = `\nexport const ${makeCapitalized(relName)} = type({${undeclared}...${baseSchema}.t,${fields}})`;
-	if (withType) return `${obj}\n\n${inferArktype(schema.name)}\n`;
-	return `${obj}`;
-}
-/**
-* 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
-* @param relation - Whether to include relation schemas in the generated code
-*/
-async function sizukuArktype(code, output, comment, type, relation) {
-	const importLine = `import { type } from 'arktype'`;
-	const baseSchemas = extractSchemas(code, "arktype");
-	const relationSchemas = extractRelationSchemas(code, "arktype");
-	const arktypeGeneratedCode = [
-		importLine,
-		"",
-		...baseSchemas.map((schema) => arktypeCode(schema, comment ?? false, type ?? false)),
-		...relation ? relationSchemas.map((schema) => makeRelationArktypeCode(schema, type ?? false)) : []
-	].join("\n");
-	const mkdirResult = await mkdir(path.dirname(output));
-	if (!mkdirResult.ok) return {
-		ok: false,
-		error: mkdirResult.error
-	};
-	const writeFileResult = await writeFile(output, await fmt(arktypeGeneratedCode));
-	if (!writeFileResult.ok) return {
-		ok: false,
-		error: writeFileResult.error
-	};
-	return {
-		ok: true,
-		value: void 0
-	};
+	}).filter((schema) => schema !== null);
 }
 //#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
-*/
+//#region src/helper/extract-tables.ts
 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 {
+	if (!match) return null;
+	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;
@@ -841,13 +284,6 @@ function extractFieldInfo(prop, code) {
 		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;
@@ -867,139 +303,88 @@ function extractRelationFromField(prop, tableName) {
 		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;
+	if (!Node.isArrowFunction(constraintArg)) return [];
 	const body = constraintArg.getBody();
-	if (!body) return relations;
+	if (!body) return [];
 	const objExpr = Node.isParenthesizedExpression(body) ? body.getExpression() : body;
-	if (!Node.isObjectLiteralExpression(objExpr)) return relations;
-	for (const prop of objExpr.getProperties()) {
-		if (!Node.isPropertyAssignment(prop)) continue;
+	if (!Node.isObjectLiteralExpression(objExpr)) return [];
+	return objExpr.getProperties().flatMap((prop) => {
+		if (!Node.isPropertyAssignment(prop)) return [];
 		const initExpr = prop.getInitializer();
-		if (!initExpr) continue;
+		if (!initExpr) return [];
 		const text = initExpr.getText();
-		if (!text.includes("foreignKey(")) continue;
+		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;
+		if (!columnsMatch || !foreignColumnsMatch) return [];
+		return [{
+			fromModel: foreignColumnsMatch[1],
+			toModel: tableName,
+			fromField: foreignColumnsMatch[2],
+			toField: columnsMatch[2],
+			isRequired: !text.includes(".nullable()")
+		}];
+	});
+}
+function isFkLikeName(name) {
+	const lower = name.toLowerCase();
+	return lower.endsWith("id") && lower !== "id" || lower.endsWith("_id");
 }
-/**
-* 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 = [];
-	for (const stmt of file.getVariableStatements().filter((stmt) => stmt.isExported())) {
+	return file.getVariableStatements().filter((stmt) => stmt.isExported()).flatMap((stmt) => {
 		const decl = stmt.getDeclarations()[0];
-		if (!Node.isVariableDeclaration(decl)) continue;
-		if (!decl.getName().toLowerCase().includes("relation")) continue;
+		if (!Node.isVariableDeclaration(decl)) return [];
+		if (!decl.getName().toLowerCase().includes("relation")) return [];
 		const init = decl.getInitializer();
-		if (!(init && Node.isCallExpression(init))) continue;
-		if (init.getExpression().getText() !== "relations") continue;
+		if (!(init && Node.isCallExpression(init))) return [];
+		if (init.getExpression().getText() !== "relations") return [];
 		const args = init.getArguments();
-		if (args.length < 2) continue;
+		if (args.length < 2) return [];
 		const tableRef = args[0];
-		if (!Node.isIdentifier(tableRef)) continue;
-		const tableName = tableRef.getText();
 		const arrowFn = args[1];
-		if (!Node.isArrowFunction(arrowFn)) continue;
+		if (!Node.isIdentifier(tableRef) || !Node.isArrowFunction(arrowFn)) return [];
+		const tableName = tableRef.getText();
 		const body = arrowFn.getBody();
-		if (!body) continue;
+		if (!body) return [];
 		const objExpr = Node.isParenthesizedExpression(body) ? body.getExpression() : body;
-		if (!Node.isObjectLiteralExpression(objExpr)) continue;
-		for (const prop of objExpr.getProperties()) {
-			if (!Node.isPropertyAssignment(prop)) continue;
+		if (!Node.isObjectLiteralExpression(objExpr)) return [];
+		return objExpr.getProperties().flatMap((prop) => {
+			if (!Node.isPropertyAssignment(prop)) return [];
 			const initExpr = prop.getInitializer();
-			if (!(initExpr && Node.isCallExpression(initExpr))) continue;
-			if (initExpr.getExpression().getText() !== "one") continue;
+			if (!(initExpr && Node.isCallExpression(initExpr))) return [];
+			if (initExpr.getExpression().getText() !== "one") return [];
 			const relArgs = initExpr.getArguments();
-			if (relArgs.length < 2) continue;
+			if (relArgs.length < 2) return [];
 			const refTableArg = relArgs[0];
-			if (!Node.isIdentifier(refTableArg)) continue;
-			const refTable = refTableArg.getText();
 			const configArg = relArgs[1];
-			if (!Node.isObjectLiteralExpression(configArg)) continue;
+			if (!Node.isIdentifier(refTableArg) || !Node.isObjectLiteralExpression(configArg)) return [];
+			const refTable = refTableArg.getText();
 			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;
+			if (!fieldsMatch || !referencesMatch) return [];
+			const currentField = fieldsMatch[2];
+			const refField = referencesMatch[2];
+			const currentIsFk = isFkLikeName(currentField);
+			const refIsFk = isFkLikeName(refField);
+			if (!currentIsFk && refIsFk) return [{
+				fromModel: tableName,
+				toModel: refTable,
+				fromField: currentField,
+				toField: refField,
+				isRequired: true
+			}];
+			return [{
+				fromModel: refTable,
+				toModel: tableName,
+				fromField: refField,
+				toField: currentField,
+				isRequired: true
+			}];
+		});
+	});
 }
-/**
-* 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) => {
@@ -1015,61 +400,71 @@ function parseTableInfo(code) {
 		if (!(objLit && Node.isObjectLiteralExpression(objLit))) return [];
 		return [{
 			name: varName,
-			fields: objLit.getProperties().filter(Node.isPropertyAssignment).map((prop) => extractFieldInfo(prop, code)).filter(isFieldInfo)
+			fields: objLit.getProperties().filter(Node.isPropertyAssignment).map((prop) => extractFieldInfo(prop, code)).filter((f) => f !== null)
 		}];
 	});
 }
-/**
-* 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 = [];
-	for (const stmt of file.getVariableStatements().filter((stmt) => stmt.isExported())) {
+	const allRelations = [...file.getVariableStatements().filter((stmt) => stmt.isExported()).flatMap((stmt) => {
 		const decl = stmt.getDeclarations()[0];
-		if (!Node.isVariableDeclaration(decl)) continue;
+		if (!Node.isVariableDeclaration(decl)) return [];
 		const varName = decl.getName();
-		if (varName.toLowerCase().includes("relation")) continue;
+		if (varName.toLowerCase().includes("relation")) return [];
 		const init = decl.getInitializer();
-		if (!(init && Node.isCallExpression(init))) continue;
+		if (!(init && Node.isCallExpression(init))) return [];
 		const callee = init.getExpression().getText();
-		if (!callee.endsWith("Table") || callee === "relations") continue;
+		if (!callee.endsWith("Table") || callee === "relations") return [];
 		const args = init.getArguments();
 		const objLit = args[1];
-		if (objLit && Node.isObjectLiteralExpression(objLit)) for (const prop of objLit.getProperties().filter(Node.isPropertyAssignment)) {
-			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 fieldRelations = objLit && Node.isObjectLiteralExpression(objLit) ? objLit.getProperties().filter(Node.isPropertyAssignment).map((prop) => extractRelationFromField(prop, varName)).filter((r) => r !== null) : [];
+		const fkRelations = constraintArg && Node.isExpression(constraintArg) ? extractRelationsFromForeignKeyConstraints(varName, constraintArg) : [];
+		return [...fieldRelations, ...fkRelations];
+	}), ...extractRelationsFromRelationBlocks(file)];
 	const seen = /* @__PURE__ */ new Set();
-	return relations.filter((r) => {
-		const key = relationKey(r);
+	return allRelations.filter((r) => {
+		const key = `${r.fromModel}.${r.fromField}->${r.toModel}.${r.toField}`;
 		if (seen.has(key)) return false;
 		seen.add(key);
 		return true;
 	});
 }
 //#endregion
-//#region src/generator/dbml/generator/dbml-content.ts
-/**
-* Map Drizzle column types to DBML types
-*/
-function mapDrizzleType(drizzleType) {
-	return {
+//#region src/generator/arktype.ts
+function undeclared(objectType) {
+	if (objectType === "strict") return "\"+\":\"reject\",";
+	if (objectType === "loose") return "\"+\":\"ignore\",";
+	return "";
+}
+function arktype(code, comment, type, relation) {
+	const c = comment ?? false;
+	const t = type ?? false;
+	const baseLines = extractSchemas(code, "arktype").map((schema) => {
+		const cap = makeCapitalized(schema.name);
+		const head = `export const ${cap}Schema = type({${undeclared(schema.objectType)}${fieldDefinitions(schema, c)}})`;
+		return t ? `${head}\n\nexport type ${cap} = typeof ${cap}Schema.infer\n` : `${head}\n`;
+	});
+	const relationLines = relation ? extractRelationSchemas(code, "arktype").map((schema) => {
+		const relSchema = makeCapitalized(`${schema.name}Schema`);
+		const baseSchema = `${makeCapitalized(schema.baseName)}Schema`;
+		const obj = `\nexport const ${relSchema} = type({${undeclared(schema.objectType)}...${baseSchema}.t,${makeRelationFields(schema.fields)}})`;
+		if (!t) return obj;
+		const cap = makeCapitalized(schema.name);
+		return `${obj}\n\nexport type ${cap} = typeof ${cap}Schema.infer\n`;
+	}) : [];
+	return [
+		`import { type } from 'arktype'`,
+		"",
+		...baseLines,
+		...relationLines
+	].join("\n");
+}
+//#endregion
+//#region src/generator/dbml.ts
+function dbml(code) {
+	const TYPE_MAP = {
 		serial: "serial",
 		smallserial: "smallserial",
 		bigserial: "bigserial",
@@ -1095,221 +490,148 @@ function mapDrizzleType(drizzleType) {
 		uuid: "uuid",
 		blob: "blob",
 		bytea: "bytea"
-	}[drizzleType] ?? drizzleType;
-}
-function escapeNote(str) {
-	return str.replace(/'/g, "\\'");
-}
-function quote(value) {
-	return `'${escapeNote(value)}'`;
-}
-function makeColumnConstraints(column) {
-	const constraints = [];
-	if (column.isPrimaryKey) constraints.push("pk");
-	if (column.isIncrement) constraints.push("increment");
-	if (column.isUnique) constraints.push("unique");
-	if (column.isNotNull && !column.isPrimaryKey) constraints.push("not null");
-	if (column.defaultValue !== void 0) constraints.push(`default: ${column.defaultValue}`);
-	if (column.note) constraints.push(`note: ${quote(column.note)}`);
-	return constraints;
-}
-function formatConstraints(constraints) {
-	return constraints.length > 0 ? ` [${constraints.join(", ")}]` : "";
-}
-function makeColumn(column) {
-	const constraints = makeColumnConstraints(column);
-	return `  ${column.name} ${column.type}${formatConstraints(constraints)}`;
-}
-function makeTable(table) {
-	const lines = [];
-	lines.push(`Table ${table.name} {`);
-	for (const column of table.columns) lines.push(makeColumn(column));
-	if (table.note) {
-		lines.push("");
-		lines.push(`  Note: ${quote(table.note)}`);
-	}
-	lines.push("}");
-	return lines.join("\n");
-}
-function makeEnum(enumDef) {
-	const lines = [];
-	lines.push(`Enum ${enumDef.name} {`);
-	for (const value of enumDef.values) lines.push(`  ${value}`);
-	lines.push("}");
-	return lines.join("\n");
-}
-function makeRefName(ref) {
-	return ref.name ?? `${ref.fromTable}_${ref.fromColumn}_${ref.toTable}_${ref.toColumn}_fk`;
-}
-function makeRef(ref) {
-	const name = makeRefName(ref);
-	const operator = ref.type ?? ">";
-	const actions = [];
-	if (ref.onDelete) actions.push(`delete: ${ref.onDelete}`);
-	if (ref.onUpdate) actions.push(`update: ${ref.onUpdate}`);
-	const actionStr = actions.length > 0 ? ` [${actions.join(", ")}]` : "";
-	return `Ref ${name}: ${ref.fromTable}.${ref.fromColumn} ${operator} ${ref.toTable}.${ref.toColumn}${actionStr}`;
-}
-function makeDBMLContent(options) {
-	const sections = [];
-	if (options.enums) for (const enumDef of options.enums) sections.push(makeEnum(enumDef));
-	for (const table of options.tables) sections.push(makeTable(table));
-	if (options.refs) for (const ref of options.refs) sections.push(makeRef(ref));
-	return sections.join("\n\n");
-}
-/**
-* 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)
 	};
+	const tables = parseTableInfo(code);
+	const relations = extractRelationsFromSchema(code);
+	const tableSections = tables.map((table) => {
+		const columns = table.fields.map((field) => {
+			const type = TYPE_MAP[field.type] ?? field.type;
+			const constraints = [
+				field.keyType === "PK" ? "pk" : null,
+				field.type.includes("serial") ? "increment" : null,
+				field.description ? `note: '${field.description.replace(/'/g, "\\'")}'` : null
+			].filter((c) => c !== null);
+			const constraintStr = constraints.length > 0 ? ` [${constraints.join(", ")}]` : "";
+			return `  ${field.name} ${type}${constraintStr}`;
+		});
+		return [
+			`Table ${table.name} {`,
+			...columns,
+			"}"
+		].join("\n");
+	});
+	const refSections = relations.map((r) => {
+		const fromTable = r.toModel;
+		const fromColumn = r.toField;
+		const toTable = r.fromModel;
+		const toColumn = r.fromField;
+		return `Ref ${`${fromTable}_${fromColumn}_${toTable}_${toColumn}_fk`}: ${fromTable}.${fromColumn} > ${toTable}.${toColumn}`;
+	});
+	return [...tableSections, ...refSections].join("\n\n");
 }
-/**
-* 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 makeDBMLContent({
-		tables: tables.map(toDBMLTable),
-		refs: relations.map(toDBMLRef)
+//#endregion
+//#region src/generator/effect.ts
+function effect(code, comment, type, relation) {
+	const c = comment ?? false;
+	const t = type ?? false;
+	const baseLines = extractSchemas(code, "effect").map((schema) => {
+		const cap = makeCapitalized(schema.name);
+		const head = `export const ${cap}Schema = Schema.Struct({${fieldDefinitions(schema, c)}})`;
+		return t ? `${head}\n\nexport type ${cap}Encoded = typeof ${cap}Schema.Encoded\n` : `${head}\n`;
 	});
+	const relationLines = relation ? extractRelationSchemas(code, "effect").map((schema) => {
+		const obj = `\nexport const ${makeCapitalized(`${schema.name}Schema`)} = Schema.Struct({...${`${makeCapitalized(schema.baseName)}Schema`}.fields,${makeRelationFields(schema.fields)}})`;
+		if (!t) return obj;
+		const cap = makeCapitalized(schema.name);
+		return `${obj}\n\nexport type ${cap}Encoded = typeof ${cap}Schema.Encoded\n`;
+	}) : [];
+	return [
+		`import { Schema } from 'effect'`,
+		"",
+		...baseLines,
+		...relationLines
+	].join("\n");
 }
 //#endregion
-//#region src/generator/dbml/index.ts
-/**
-* Generate DBML content string from Drizzle schema code
-*/
-function generateContent(code) {
-	const tables = parseTableInfo(code);
-	return dbmlContent(extractRelationsFromSchema(code), tables);
-}
-/**
-* Generate DBML file from Drizzle schema code
-*
-* @param code - The code to generate DBML from
-* @param output - The output file path (must end with .dbml)
-*/
-async function sizukuDbmlFile(code, output) {
-	const content = generateContent(code);
-	const mkdirResult = await mkdir(dirname(output));
-	if (!mkdirResult.ok) return {
-		ok: false,
-		error: `❌ Failed to create directory: ${mkdirResult.error}`
-	};
-	const writeResult = await writeFile(output, content);
-	if (!writeResult.ok) return {
-		ok: false,
-		error: `❌ Failed to write DBML: ${writeResult.error}`
-	};
-	return {
-		ok: true,
-		value: void 0
-	};
-}
-/**
-* Generate PNG ER diagram from Drizzle schema code
-*
-* @param code - The code to generate PNG from
-* @param output - The output file path (must end with .png)
-*/
-/**
-* Generate ERD output (DBML or PNG) based on file extension
-*/
-async function sizukuDbml(code, output) {
-	if (output.endsWith(".png")) return sizukuPng(code, output);
-	return sizukuDbmlFile(code, output);
-}
-async function sizukuPng(code, output) {
-	const pngBuffer = new Resvg(run(generateContent(code), "svg"), { font: { loadSystemFonts: true } }).render().asPng();
-	const mkdirResult = await mkdir(dirname(output));
-	if (!mkdirResult.ok) return {
-		ok: false,
-		error: `❌ Failed to create directory: ${mkdirResult.error}`
-	};
-	const writeResult = await writeFileBinary(output, pngBuffer);
-	if (!writeResult.ok) return {
+//#region src/format/index.ts
+async function fmt(input) {
+	const { code, errors } = await format("<stdin>.ts", input, {
+		printWidth: 100,
+		singleQuote: true,
+		semi: false
+	});
+	if (errors.length > 0) return {
 		ok: false,
-		error: `❌ Failed to write PNG: ${writeResult.error}`
+		error: errors.map((e) => e.message).join("\n")
 	};
 	return {
 		ok: true,
-		value: void 0
+		value: code
 	};
 }
 //#endregion
-//#region src/generator/effect/index.ts
-function effect(schema, comment) {
-	const inner = fieldDefinitions(schema, comment);
-	return `export const ${makeCapitalized(schema.name)}Schema = Schema.Struct({${inner}})`;
+//#region src/fsp/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)
+		};
+	}
+}
+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)
+		};
+	}
 }
-function effectCode(schema, comment, type) {
-	const effectSchema = effect(schema, comment);
-	if (type) return `${effectSchema}\n\n${inferEffect(schema.name)}\n`;
-	return `${effectSchema}\n`;
+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)
+		};
+	}
 }
-function makeRelationEffectCode(schema, withType) {
-	const relName = `${schema.name}Schema`;
-	const baseSchema = `${makeCapitalized(schema.baseName)}Schema`;
-	const fields = makeRelationFields(schema.fields);
-	const obj = `\nexport const ${makeCapitalized(relName)} = Schema.Struct({...${baseSchema}.fields,${fields}})`;
-	if (withType) return `${obj}\n\n${inferEffect(schema.name)}\n`;
-	return `${obj}`;
+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)
+		};
+	}
 }
-/**
-* 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
-* @param relation - Whether to include relation schemas in the generated code
-*/
-async function sizukuEffect(code, output, comment, type, relation) {
-	const importLine = `import { Schema } from 'effect'`;
-	const baseSchemas = extractSchemas(code, "effect");
-	const relationSchemas = extractRelationSchemas(code, "effect");
-	const effectGeneratedCode = [
-		importLine,
-		"",
-		...baseSchemas.map((schema) => effectCode(schema, comment ?? false, type ?? false)),
-		...relation ? relationSchemas.map((schema) => makeRelationEffectCode(schema, type ?? false)) : []
-	].join("\n");
-	const mkdirResult = await mkdir(path.dirname(output));
+//#endregion
+//#region src/generator/emit.ts
+async function emit(code, dir, output) {
+	const [fmtResult, mkdirResult] = await Promise.all([fmt(code), mkdir(dir)]);
+	if (!fmtResult.ok) return {
+		ok: false,
+		error: fmtResult.error
+	};
 	if (!mkdirResult.ok) return {
 		ok: false,
 		error: mkdirResult.error
 	};
-	const writeFileResult = await writeFile(output, await fmt(effectGeneratedCode));
-	if (!writeFileResult.ok) return {
+	const writeResult = await writeFile(output, fmtResult.value);
+	if (!writeResult.ok) return {
 		ok: false,
-		error: writeFileResult.error
+		error: writeResult.error
 	};
 	return {
 		ok: true,
@@ -1317,43 +639,11 @@ async function sizukuEffect(code, output, comment, type, relation) {
 	};
 }
 //#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 makeRelationLine(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(makeRelationLine));
+//#region src/generator/mermaid-er.ts
+function mermaidER(code) {
+	const tables = parseTableInfo(code);
+	const relations = extractRelationsFromSchema(code);
+	const relationLines = [...new Set(relations.map((r) => `    ${r.fromModel} ||--${r.isRequired ? "}|" : "}o"} ${r.toModel} : "(${r.fromField}) - (${r.toField})"`))];
 	const tableDefinitions = tables.flatMap((table) => [
 		`    ${table.name} {`,
 		...table.fields.map((field) => {
@@ -1364,83 +654,93 @@ function erContent(relations, tables) {
 		"    }"
 	]);
 	return [
-		...ER_HEADER,
+		"```mermaid",
+		"erDiagram",
 		...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
-	};
+//#region src/generator/valibot.ts
+function valibot(code, comment, type, relation) {
+	const c = comment ?? false;
+	const t = type ?? false;
+	const baseLines = extractSchemas(code, "valibot").map((schema) => {
+		const cap = makeCapitalized(schema.name);
+		const head = `export const ${cap}Schema = v.${resolveWrapperType(schema.objectType)}({${fieldDefinitions(schema, c)}})`;
+		return t ? `${head}\n\nexport type ${cap} = v.InferOutput<typeof ${cap}Schema>\n` : `${head}\n`;
+	});
+	const relationLines = relation ? extractRelationSchemas(code, "valibot").map((schema) => {
+		const relSchema = makeCapitalized(`${schema.name}Schema`);
+		const baseSchema = `${makeCapitalized(schema.baseName)}Schema`;
+		const obj = `\nexport const ${relSchema} = v.${resolveWrapperType(schema.objectType)}({...${baseSchema}.entries,${makeRelationFields(schema.fields)}})`;
+		if (!t) return obj;
+		const cap = makeCapitalized(schema.name);
+		return `${obj}\n\nexport type ${cap} = v.InferOutput<typeof ${cap}Schema>\n`;
+	}) : [];
+	return [
+		"import * as v from 'valibot'",
+		"",
+		...baseLines,
+		...relationLines
+	].join("\n");
 }
 //#endregion
-//#region src/generator/valibot/index.ts
-function valibot(schema, comment) {
-	const wrapperType = resolveWrapperType(schema.objectType);
-	const objectCode = makeValibotObject(fieldDefinitions(schema, comment), wrapperType);
-	return `export const ${makeCapitalized(schema.name)}Schema = ${objectCode}`;
-}
-function valibotCode(schema, comment, type) {
-	const valibotSchema = valibot(schema, comment);
-	if (type) return `${valibotSchema}\n\n${inferOutput(schema.name)}\n`;
-	return `${valibotSchema}\n`;
-}
-function relationValibotCode(schema, withType) {
-	const relName = `${schema.name}Schema`;
-	const baseSchema = `${makeCapitalized(schema.baseName)}Schema`;
-	const fields = makeRelationFields(schema.fields);
-	const objectType = resolveWrapperType(schema.objectType);
-	const obj = `\nexport const ${makeCapitalized(relName)} = v.${objectType}({...${baseSchema}.entries,${fields}})`;
-	if (withType) return `${obj}\n\n${inferOutput(schema.name)}\n`;
-	return `${obj}`;
-}
-/**
-* 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'",
+//#region src/generator/zod.ts
+function zod(code, comment, type, version, relation) {
+	const c = comment ?? false;
+	const t = type ?? false;
+	const importLine = version === "mini" ? `import * as z from 'zod/mini'` : version === "@hono/zod-openapi" ? `import { z } from '@hono/zod-openapi'` : `import * as z from 'zod'`;
+	const baseLines = extractSchemas(code, "zod").map((schema) => {
+		const cap = makeCapitalized(schema.name);
+		const head = `export const ${cap}Schema = z.${resolveWrapperType(schema.objectType)}({${fieldDefinitions(schema, c)}})`;
+		return t ? `${head}\n\nexport type ${cap} = z.infer<typeof ${cap}Schema>\n` : `${head}\n`;
+	});
+	const relationLines = relation ? extractRelationSchemas(code, "zod").map((schema) => {
+		const relSchema = makeCapitalized(`${schema.name}Schema`);
+		const baseSchema = `${makeCapitalized(schema.baseName)}Schema`;
+		const obj = `\nexport const ${relSchema} = z.${resolveWrapperType(schema.objectType)}({...${baseSchema}.shape,${makeRelationFields(schema.fields)}})`;
+		if (!t) return obj;
+		const cap = makeCapitalized(schema.name);
+		return `${obj}\n\nexport type ${cap} = z.infer<typeof ${cap}Schema>\n`;
+	}) : [];
+	return [
+		importLine,
 		"",
-		...baseSchemas.map((schema) => valibotCode(schema, comment ?? false, type ?? false)),
-		...relation ? relationSchemas.map((schema) => relationValibotCode(schema, type ?? false)) : []
+		...baseLines,
+		...relationLines
 	].join("\n");
-	const mkdirResult = await mkdir(path.dirname(output));
+}
+//#endregion
+//#region src/core/arktype.ts
+function sizukuArktype(code, output, comment, type, relation) {
+	return emit(arktype(code, comment, type, relation), path.dirname(output), output);
+}
+//#endregion
+//#region src/core/dbml.ts
+async function sizukuDbml(code, output) {
+	const content = dbml(code);
+	const mkdirResult = await mkdir(dirname(output));
 	if (!mkdirResult.ok) return {
 		ok: false,
-		error: mkdirResult.error
+		error: `❌ Failed to create directory: ${mkdirResult.error}`
 	};
-	const writeFileResult = await writeFile(output, await fmt(valibotGeneratedCode));
-	if (!writeFileResult.ok) return {
+	if (output.endsWith(".png")) {
+		const writeResult = await writeFileBinary(output, new Resvg(run(content, "svg"), { font: { loadSystemFonts: true } }).render().asPng());
+		if (!writeResult.ok) return {
+			ok: false,
+			error: `❌ Failed to write PNG: ${writeResult.error}`
+		};
+		return {
+			ok: true,
+			value: void 0
+		};
+	}
+	const writeResult = await writeFile(output, content);
+	if (!writeResult.ok) return {
 		ok: false,
-		error: writeFileResult.error
+		error: `❌ Failed to write DBML: ${writeResult.error}`
 	};
 	return {
 		ok: true,
@@ -1448,50 +748,20 @@ async function sizukuValibot(code, output, comment, type, relation) {
 	};
 }
 //#endregion
-//#region src/generator/zod/index.ts
-function zod(schema, comment) {
-	const wrapperType = resolveWrapperType(schema.objectType);
-	const objectCode = makeZodObject(fieldDefinitions(schema, comment), wrapperType);
-	return `export const ${makeCapitalized(schema.name)}Schema = ${objectCode}`;
-}
-function zodCode(schema, comment, type) {
-	const zodSchema = zod(schema, comment);
-	if (type) return `${zodSchema}\n\n${infer(schema.name)}\n`;
-	return `${zodSchema}\n`;
+//#region src/core/effect.ts
+function sizukuEffect(code, output, comment, type, relation) {
+	return emit(effect(code, comment, type, relation), path.dirname(output), output);
 }
-function relationZodCode(schema, withType) {
-	const relName = `${schema.name}Schema`;
-	const baseSchema = `${makeCapitalized(schema.baseName)}Schema`;
-	const fields = makeRelationFields(schema.fields);
-	const objectType = resolveWrapperType(schema.objectType);
-	const obj = `\nexport const ${makeCapitalized(relName)} = z.${objectType}({...${baseSchema}.shape,${fields}})`;
-	if (withType) return `${obj}\n\n${infer(schema.name)}\n`;
-	return `${obj}`;
-}
-/**
-* 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");
+//#endregion
+//#region src/core/mermaid-er.ts
+async function sizukuMermaidER(code, output) {
+	const content = mermaidER(code);
 	const mkdirResult = await mkdir(path.dirname(output));
 	if (!mkdirResult.ok) return {
 		ok: false,
 		error: mkdirResult.error
 	};
-	const writeFileResult = await writeFile(output, await fmt(zodGeneratedCode));
+	const writeFileResult = await writeFile(output, content);
 	if (!writeFileResult.ok) return {
 		ok: false,
 		error: writeFileResult.error
@@ -1502,6 +772,16 @@ async function sizukuZod(code, output, comment, type, zod, relation) {
 	};
 }
 //#endregion
+//#region src/core/valibot.ts
+function sizukuValibot(code, output, comment, type, relation) {
+	return emit(valibot(code, comment, type, relation), path.dirname(output), output);
+}
+//#endregion
+//#region src/core/zod.ts
+function sizukuZod(code, output, comment, type, version, relation) {
+	return emit(zod(code, comment, type, version, relation), path.dirname(output), output);
+}
+//#endregion
 //#region src/cli/index.ts
 const HELP_TEXT = `💧 sizuku - Drizzle ORM schema tools
 
@@ -1519,124 +799,25 @@ Options:
   --no-with-comment                 Do not add JSDoc comments
   --no-with-relation                Do not generate relation schemas
   -h, --help                        Display this help message`;
-/**
-* Detect output type from file extension
-*/
-function detectOutputType(output) {
-	if (output.endsWith(".dbml")) return "dbml";
-	if (output.endsWith(".png")) return "png";
-	if (output.endsWith(".md")) return "mermaid";
-	if (output.endsWith(".ts")) return "typescript";
-	return null;
-}
-/**
-* Parse CLI flags from argv (pure function)
-*/
 function parseFlags(argv) {
-	const has = (flag) => argv.includes(flag);
+	const ZOD_VERSIONS = [
+		"v4",
+		"mini",
+		"@hono/zod-openapi"
+	];
 	const zodVersionIndex = argv.findIndex((a) => a === "--zod-version" || a.startsWith("--zod-version="));
-	const zodVersion = (() => {
-		if (zodVersionIndex === -1) return void 0;
-		const arg = argv[zodVersionIndex];
-		const value = arg.includes("=") ? arg.split("=")[1] : argv[zodVersionIndex + 1];
-		if (value === "v4" || value === "mini" || value === "@hono/zod-openapi") return value;
-	})();
-	return {
-		zod: has("--zod"),
-		valibot: has("--valibot"),
-		arktype: has("--arktype"),
-		effect: has("--effect"),
-		zodVersion,
-		exportTypes: !has("--no-export-types"),
-		withComment: !has("--no-with-comment"),
-		withRelation: !has("--no-with-relation")
-	};
-}
-/**
-* Strip import lines from source code and return only schema definition lines
-*/
-function stripImports(content) {
-	const lines = content.split("\n");
-	const codeStart = lines.findIndex((line) => !line.trim().startsWith("import") && line.trim() !== "");
-	return lines.slice(codeStart);
-}
-/**
-* Run sizuku in direct CLI mode for diagram output
-*/
-async function sizukuDirectDiagram(input, output, outputType) {
-	const contentResult = readFileSync(input);
-	if (!contentResult.ok) return {
-		ok: false,
-		error: `Failed to read input: ${contentResult.error}`
-	};
-	const code = stripImports(contentResult.value);
-	if (outputType === "dbml" || outputType === "png") {
-		const result = await sizukuDbml(code, output);
-		if (!result.ok) return result;
-		return {
-			ok: true,
-			value: `💧 Generated ${outputType === "png" ? "PNG" : "DBML"} at: ${output}`
-		};
-	}
-	const result = await sizukuMermaidER(code, output);
-	if (!result.ok) return result;
+	const zodVersionValue = zodVersionIndex === -1 ? void 0 : argv[zodVersionIndex].includes("=") ? argv[zodVersionIndex].split("=")[1] : argv[zodVersionIndex + 1];
 	return {
-		ok: true,
-		value: `💧 Generated Mermaid ER at: ${output}`
+		zod: argv.includes("--zod"),
+		valibot: argv.includes("--valibot"),
+		arktype: argv.includes("--arktype"),
+		effect: argv.includes("--effect"),
+		zodVersion: ZOD_VERSIONS.find((v) => v === zodVersionValue),
+		exportTypes: !argv.includes("--no-export-types"),
+		withComment: !argv.includes("--no-with-comment"),
+		withRelation: !argv.includes("--no-with-relation")
 	};
 }
-/**
-* Resolve which schema library to use from flags
-*/
-function resolveSchemaLibrary(flags) {
-	if (flags.zod) return {
-		name: "zod",
-		label: "Zod"
-	};
-	if (flags.valibot) return {
-		name: "valibot",
-		label: "Valibot"
-	};
-	if (flags.arktype) return {
-		name: "arktype",
-		label: "ArkType"
-	};
-	if (flags.effect) return {
-		name: "effect",
-		label: "Effect"
-	};
-	return null;
-}
-/**
-* Run sizuku in direct CLI mode for validation schema output
-*/
-async function sizukuDirectSchema(input, output, flags) {
-	const lib = resolveSchemaLibrary(flags);
-	if (!lib) return {
-		ok: false,
-		error: "Specify --zod, --valibot, --arktype, or --effect for .ts output"
-	};
-	const contentResult = readFileSync(input);
-	if (!contentResult.ok) return {
-		ok: false,
-		error: `Failed to read input: ${contentResult.error}`
-	};
-	const code = stripImports(contentResult.value);
-	const result = await {
-		zod: () => sizukuZod(code, output, flags.withComment, flags.exportTypes, flags.zodVersion, flags.withRelation),
-		valibot: () => sizukuValibot(code, output, flags.withComment, flags.exportTypes, flags.withRelation),
-		arktype: () => sizukuArktype(code, output, flags.withComment, flags.exportTypes, flags.withRelation),
-		effect: () => sizukuEffect(code, output, flags.withComment, flags.exportTypes, flags.withRelation)
-	}[lib.name]();
-	if (!result.ok) return result;
-	return {
-		ok: true,
-		value: `💧 Generated ${lib.label} schema at: ${output}`
-	};
-}
-/**
-* Main entry point
-*/
 async function sizuku() {
 	const argv = process.argv.slice(2);
 	if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) return {
@@ -1658,13 +839,66 @@ async function sizuku() {
 		ok: false,
 		error: "Missing output file path after -o"
 	};
-	const outputType = detectOutputType(output);
+	const outputType = output.endsWith(".dbml") ? "dbml" : output.endsWith(".png") ? "png" : output.endsWith(".md") ? "mermaid" : output.endsWith(".ts") ? "typescript" : null;
 	if (!outputType) return {
 		ok: false,
 		error: `Unsupported output format: ${output}. Supported: .dbml, .png, .md, .ts`
 	};
-	if (outputType === "typescript") return sizukuDirectSchema(input, output, parseFlags(argv));
-	return sizukuDirectDiagram(input, output, outputType);
+	const flags = outputType === "typescript" ? parseFlags(argv) : null;
+	const lib = flags === null ? null : flags.zod ? {
+		name: "zod",
+		label: "Zod"
+	} : flags.valibot ? {
+		name: "valibot",
+		label: "Valibot"
+	} : flags.arktype ? {
+		name: "arktype",
+		label: "ArkType"
+	} : flags.effect ? {
+		name: "effect",
+		label: "Effect"
+	} : null;
+	if (outputType === "typescript" && !lib) return {
+		ok: false,
+		error: "Specify --zod, --valibot, --arktype, or --effect for .ts output"
+	};
+	const contentResult = readFileSync(input);
+	if (!contentResult.ok) return {
+		ok: false,
+		error: `Failed to read input: ${contentResult.error}`
+	};
+	const code = stripImports(contentResult.value);
+	if (outputType === "dbml" || outputType === "png") {
+		const result = await sizukuDbml(code, output);
+		if (!result.ok) return result;
+		return {
+			ok: true,
+			value: `💧 Generated ${outputType === "png" ? "PNG" : "DBML"} at: ${output}`
+		};
+	}
+	if (outputType === "mermaid") {
+		const result = await sizukuMermaidER(code, output);
+		if (!result.ok) return result;
+		return {
+			ok: true,
+			value: `💧 Generated Mermaid ER at: ${output}`
+		};
+	}
+	if (!lib || !flags) return {
+		ok: false,
+		error: "internal: missing lib/flags"
+	};
+	const result = await (() => {
+		if (lib.name === "zod") return sizukuZod(code, output, flags.withComment, flags.exportTypes, flags.zodVersion, flags.withRelation);
+		if (lib.name === "valibot") return sizukuValibot(code, output, flags.withComment, flags.exportTypes, flags.withRelation);
+		if (lib.name === "arktype") return sizukuArktype(code, output, flags.withComment, flags.exportTypes, flags.withRelation);
+		return sizukuEffect(code, output, flags.withComment, flags.exportTypes, flags.withRelation);
+	})();
+	if (!result.ok) return result;
+	return {
+		ok: true,
+		value: `💧 Generated ${lib.label} schema at: ${output}`
+	};
 }
 //#endregion
 //#region src/index.ts