on-zero 0.16.17 → 0.16.19

package/dist/cjs/generate.native.js

@@ -45,12 +45,15 @@ module.exports = __toCommonJS(generate_exports);
 var import_crypto = require("crypto");
 var import_fs = require("fs");
 var import_path = require("path");
+var ts = __toESM(require("typescript/unstable/ast"), 1);
+var import_async = require("typescript/unstable/async");
 var import_generate_helpers = require("./generate-helpers.native.js");
 var import_generate_layout = require("./generate-layout.native.js");
+var import_native_typescript = require("./native-typescript.native.js");
 var hash = function hash2(s) {
   return (0, import_crypto.createHash)("sha256").update(s).digest("hex");
 };
-var GENERATOR_CACHE_VERSION = "6";
+var GENERATOR_CACHE_VERSION = "7";
 var isGeneratorSourceFile = function isGeneratorSourceFile2(name) {
   return name.endsWith(".ts") && !name.endsWith(".d.ts") && !name.endsWith(".test.ts") && !name.endsWith(".spec.ts");
 };
@@ -155,99 +158,39 @@ function saveCache() {
 }
 function writeFileIfChanged(filePath, content) {
   var contentHash = hash(content);
-  var cachedHash = generateCache[filePath];
-  if (cachedHash === contentHash && (0, import_fs.existsSync)(filePath)) {
+  var onDisk = null;
+  try {
+    onDisk = (0, import_fs.readFileSync)(filePath, "utf-8");
+  } catch (unused) {}
+  if (onDisk !== null && hash(onDisk) === contentHash) {
+    generateCache[filePath] = contentHash;
     return false;
   }
   (0, import_fs.writeFileSync)(filePath, content, "utf-8");
   generateCache[filePath] = contentHash;
   return true;
 }
-function createTypeResolver(ts, files, dir) {
-  var configPath = ts.findConfigFile(dir, ts.sys.fileExists, "tsconfig.json");
-  var compilerOptions = {
-    target: ts.ScriptTarget.Latest,
-    module: ts.ModuleKind.ESNext,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    strict: false,
-    skipLibCheck: true,
-    noEmit: true
-  };
-  if (configPath) {
-    var configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    if (configFile.config) {
-      var parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, (0, import_path.dirname)(configPath));
-      compilerOptions = {
-        ...compilerOptions,
-        ...parsed.options
-      };
-    }
-  }
-  var fileMap = /* @__PURE__ */new Map();
-  var _iteratorNormalCompletion = true,
-    _didIteratorError = false,
-    _iteratorError = void 0;
-  try {
-    for (var _iterator = files[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-      var f = _step.value;
-      fileMap.set(f.path, f.content);
-    }
-  } catch (err) {
-    _didIteratorError = true;
-    _iteratorError = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion && _iterator.return != null) {
-        _iterator.return();
-      }
-    } finally {
-      if (_didIteratorError) {
-        throw _iteratorError;
-      }
-    }
-  }
-  var host = ts.createCompilerHost(compilerOptions);
-  var originalGetSourceFile = host.getSourceFile.bind(host);
-  host.getSourceFile = function (fileName, languageVersion, onError) {
-    var content = fileMap.get(fileName);
-    if (content !== void 0) {
-      return ts.createSourceFile(fileName, content, languageVersion, true);
-    }
-    return originalGetSourceFile(fileName, languageVersion, onError);
-  };
-  host.fileExists = function (fileName) {
-    return fileMap.has(fileName) || ts.sys.fileExists(fileName);
-  };
-  host.readFile = function (fileName) {
-    var _fileMap_get;
-    return (_fileMap_get = fileMap.get(fileName)) !== null && _fileMap_get !== void 0 ? _fileMap_get : ts.sys.readFile(fileName);
-  };
-  var program = ts.createProgram(files.map(function (f2) {
-    return f2.path;
-  }), compilerOptions, host);
-  var checker = program.getTypeChecker();
+function createTypeResolver(project) {
   return {
-    program,
-    checker,
-    // resolve a type annotation node to a ts.Type
-    resolveType(node) {
+    project,
+    async resolveType(node) {
       try {
-        return checker.getTypeFromTypeNode(node);
+        var _ref;
+        return (_ref = await project.checker.getTypeFromTypeNode(node)) !== null && _ref !== void 0 ? _ref : null;
       } catch (unused) {
         return null;
       }
     },
-    // convert a resolved type to valibot code
-    typeToValibot(type) {
-      return tsTypeToValibot(ts, checker, type);
+    async typeToValibot(type) {
+      return tsTypeToValibot(project, type);
     }
   };
 }
-function resolveParamType(ts, resolver, sourceFile, exportName, paramIndex) {
-  var result = null;
-  ts.forEachChild(sourceFile, function (node) {
+async function resolveParamType(resolver, sourceFile, exportName, paramIndex) {
+  var typeNode = null;
+  sourceFile.forEachChild(function (node) {
     var _node_modifiers;
-    if (result) return;
+    if (typeNode) return;
     if (!ts.isVariableStatement(node)) return;
     if (!((_node_modifiers = node.modifiers) === null || _node_modifiers === void 0 ? void 0 : _node_modifiers.some(function (m) {
       return m.kind === ts.SyntaxKind.ExportKeyword;
@@ -258,13 +201,13 @@ function resolveParamType(ts, resolver, sourceFile, exportName, paramIndex) {
     if (decl.initializer && ts.isArrowFunction(decl.initializer)) {
       var param = decl.initializer.parameters[paramIndex];
       if (param === null || param === void 0 ? void 0 : param.type) {
-        result = resolver.resolveType(param.type);
+        typeNode = param.type;
       }
     }
   });
-  return result;
+  return typeNode ? resolver.resolveType(typeNode) : null;
 }
-function readMutationsCall(ts, call) {
+function readMutationsCall(call) {
   var args = call.arguments;
   if (args.length < 2) {
     var only = args[0];
@@ -309,32 +252,32 @@ function readMutationsCall(ts, call) {
     handlersArg: handlers && ts.isObjectLiteralExpression(handlers) ? handlers : null
   };
 }
-function resolveMutationParamTypes(ts, resolver, sourceFile) {
-  var resolved = /* @__PURE__ */new Map();
-  ts.forEachChild(sourceFile, function (node) {
+async function resolveMutationParamTypes(resolver, sourceFile) {
+  var nodes = /* @__PURE__ */new Map();
+  sourceFile.forEachChild(function (node2) {
     var _node_modifiers;
-    if (!ts.isVariableStatement(node)) return;
-    if (!((_node_modifiers = node.modifiers) === null || _node_modifiers === void 0 ? void 0 : _node_modifiers.some(function (m) {
+    if (!ts.isVariableStatement(node2)) return;
+    if (!((_node_modifiers = node2.modifiers) === null || _node_modifiers === void 0 ? void 0 : _node_modifiers.some(function (m) {
       return m.kind === ts.SyntaxKind.ExportKeyword;
     }))) return;
-    var decl = node.declarationList.declarations[0];
+    var decl = node2.declarationList.declarations[0];
     if (!decl || !ts.isVariableDeclaration(decl)) return;
     if (decl.name.getText(sourceFile) !== "mutate") return;
     if (!decl.initializer || !ts.isCallExpression(decl.initializer)) return;
     var {
       handlersArg
-    } = readMutationsCall(ts, decl.initializer);
+    } = readMutationsCall(decl.initializer);
     if (!handlersArg) return;
-    var _iteratorNormalCompletion = true,
-      _didIteratorError = false,
-      _iteratorError = void 0;
+    var _iteratorNormalCompletion2 = true,
+      _didIteratorError2 = false,
+      _iteratorError2 = void 0;
     try {
-      for (var _iterator = handlersArg.properties[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var prop = _step.value;
+      for (var _iterator2 = handlersArg.properties[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var prop = _step2.value;
         var _prop_name;
         if (!ts.isPropertyAssignment(prop) && !ts.isMethodDeclaration(prop)) continue;
-        var name = (_prop_name = prop.name) === null || _prop_name === void 0 ? void 0 : _prop_name.getText(sourceFile);
-        if (!name) continue;
+        var name2 = (_prop_name = prop.name) === null || _prop_name === void 0 ? void 0 : _prop_name.getText(sourceFile);
+        if (!name2) continue;
         var params = null;
         if (ts.isPropertyAssignment(prop)) {
           var init = prop.initializer;
@@ -347,31 +290,52 @@ function resolveMutationParamTypes(ts, resolver, sourceFile) {
         if (!params || params.length < 2) continue;
         var typeNode = params[1].type;
         if (!typeNode) continue;
-        var expanded = resolver.resolveType(typeNode);
-        if (expanded) {
-          resolved.set(name, expanded);
-        }
+        nodes.set(name2, typeNode);
       }
     } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
     } finally {
       try {
-        if (!_iteratorNormalCompletion && _iterator.return != null) {
-          _iterator.return();
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
         }
       } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
+        if (_didIteratorError2) {
+          throw _iteratorError2;
         }
       }
     }
   });
+  var resolved = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = nodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [name, node] = _step.value;
+      var expanded = await resolver.resolveType(node);
+      if (expanded) resolved.set(name, expanded);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
   return resolved;
 }
-function extractMutationsFromModel(ts, sourceFile, content, fileName, silent, typeToValibot, resolvedTypes, resolvedTypeToValibot) {
+function extractMutationsFromModel(sourceFile, content, fileName, silent, typeToValibot, resolvedValibot) {
   var mutateNode = null;
-  ts.forEachChild(sourceFile, function (node) {
+  sourceFile.forEachChild(function (node) {
     var _node_modifiers;
     if (!ts.isVariableStatement(node)) return;
     if (!((_node_modifiers = node.modifiers) === null || _node_modifiers === void 0 ? void 0 : _node_modifiers.some(function (m) {
@@ -398,12 +362,12 @@ function extractMutationsFromModel(ts, sourceFile, content, fileName, silent, ty
     hasTable,
     crud,
     handlersArg
-  } = readMutationsCall(ts, call);
+  } = readMutationsCall(call);
   var hasCRUD = hasTable && crud;
   var columns = {};
   var primaryKeys = [];
   if (hasCRUD) {
-    extractSchemaColumns(ts, sourceFile, columns, primaryKeys);
+    extractSchemaColumns(sourceFile, columns, primaryKeys);
   }
   var custom = [];
   if (handlersArg) {
@@ -446,11 +410,9 @@ function extractMutationsFromModel(ts, sourceFile, content, fileName, silent, ty
           continue;
         }
         var valibotCode = typeToValibot(paramType);
-        if (!valibotCode && resolvedTypes && resolvedTypeToValibot) {
-          var resolvedType = resolvedTypes.get(name);
-          if (resolvedType) {
-            valibotCode = resolvedTypeToValibot(resolvedType);
-          }
+        if (!valibotCode && resolvedValibot) {
+          var _resolvedValibot_get;
+          valibotCode = (_resolvedValibot_get = resolvedValibot.get(name)) !== null && _resolvedValibot_get !== void 0 ? _resolvedValibot_get : null;
         }
         custom.push({
           name,
@@ -481,7 +443,7 @@ function extractMutationsFromModel(ts, sourceFile, content, fileName, silent, ty
     custom
   };
 }
-function extractSchemaColumns(ts, sourceFile, columns, primaryKeys) {
+function extractSchemaColumns(sourceFile, columns, primaryKeys) {
   function visit(node) {
     if (ts.isCallExpression(node)) {
       var text = node.expression.getText(sourceFile);
@@ -545,64 +507,59 @@ function extractSchemaColumns(ts, sourceFile, columns, primaryKeys) {
         }
       }
     }
-    ts.forEachChild(node, visit);
+    node.forEachChild(visit);
   }
   visit(sourceFile);
 }
-function getInstantiatedPropertyType(checker, parent, name) {
-  var resolveProperty = Reflect.get(checker, "getTypeOfPropertyOfType");
-  if (typeof resolveProperty !== "function") return void 0;
-  return Reflect.apply(resolveProperty, checker, [parent, name]);
-}
-function tsTypeToValibot(ts, checker, type, seen) {
-  var _checker_isArrayType, _checker_isArrayLikeType;
-  if (!seen) seen = /* @__PURE__ */new Set();
-  var flags = type.getFlags();
-  if (flags & (ts.TypeFlags.Object | ts.TypeFlags.Intersection)) {
-    if (seen.has(type)) return "v.unknown()";
-    seen.add(type);
+async function tsTypeToValibot(project, type) {
+  var seen = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : /* @__PURE__ */new Set();
+  var checker = project.checker;
+  var flags = type.flags;
+  if (flags & (import_async.TypeFlags.Object | import_async.TypeFlags.Intersection)) {
+    if (seen.has(type.id)) return "v.unknown()";
+    seen.add(type.id);
   }
-  var recurse = function recurse2(t) {
-    return tsTypeToValibot(ts, checker, t, seen);
+  var recurse = function recurse2(value) {
+    return tsTypeToValibot(project, value, seen);
   };
-  if (flags & ts.TypeFlags.String) return "v.string()";
-  if (flags & ts.TypeFlags.Number) return "v.number()";
-  if (flags & ts.TypeFlags.Boolean) return "v.boolean()";
-  if (flags & ts.TypeFlags.Void || flags & ts.TypeFlags.Undefined) return "v.void_()";
-  if (flags & ts.TypeFlags.Null) return "v.null_()";
-  if (flags & ts.TypeFlags.Any || flags & ts.TypeFlags.Unknown) return "v.unknown()";
-  if (flags & ts.TypeFlags.Never) return "v.never()";
-  if (flags & ts.TypeFlags.TemplateLiteral) return "v.string()";
-  if (flags & ts.TypeFlags.Object && (((_checker_isArrayType = checker.isArrayType) === null || _checker_isArrayType === void 0 ? void 0 : _checker_isArrayType.call(checker, type)) || ((_checker_isArrayLikeType = checker.isArrayLikeType) === null || _checker_isArrayLikeType === void 0 ? void 0 : _checker_isArrayLikeType.call(checker, type)))) {
-    var _ref;
-    var _checker_getTypeArguments, _type_getNumberIndexType;
-    var typeArgs = (_ref = (_checker_getTypeArguments = checker.getTypeArguments) === null || _checker_getTypeArguments === void 0 ? void 0 : _checker_getTypeArguments.call(checker, type)) !== null && _ref !== void 0 ? _ref : [];
-    var elementType = typeArgs.length === 1 ? typeArgs[0] : (_type_getNumberIndexType = type.getNumberIndexType) === null || _type_getNumberIndexType === void 0 ? void 0 : _type_getNumberIndexType.call(type);
-    return `v.array(${elementType ? recurse(elementType) : "v.unknown()"})`;
+  if (flags & import_async.TypeFlags.String) return "v.string()";
+  if (flags & import_async.TypeFlags.Number) return "v.number()";
+  if (flags & import_async.TypeFlags.Boolean) return "v.boolean()";
+  if (flags & import_async.TypeFlags.Void || flags & import_async.TypeFlags.Undefined) return "v.void_()";
+  if (flags & import_async.TypeFlags.Null) return "v.null_()";
+  if (flags & import_async.TypeFlags.Any || flags & import_async.TypeFlags.Unknown) return "v.unknown()";
+  if (flags & import_async.TypeFlags.Never) return "v.never()";
+  if (flags & import_async.TypeFlags.TemplateLiteral) return "v.string()";
+  if (flags & import_async.TypeFlags.Object && (await checker.isArrayLikeType(type))) {
+    var typeArgs = type.isTypeReference() ? await checker.getTypeArguments(type) : [];
+    var indexInfo = (await checker.getIndexInfosOfType(type)).find(function (info) {
+      return Boolean(info.keyType.flags & import_async.TypeFlags.Number);
+    });
+    var elementType = typeArgs.length === 1 ? typeArgs[0] : indexInfo === null || indexInfo === void 0 ? void 0 : indexInfo.valueType;
+    return `v.array(${elementType ? await recurse(elementType) : "v.unknown()"})`;
   }
-  if (flags & ts.TypeFlags.StringLiteral) {
+  if (type.isStringLiteralType()) {
     return `v.literal(${JSON.stringify(type.value)})`;
   }
-  if (flags & ts.TypeFlags.NumberLiteral) {
+  if (type.isNumberLiteralType()) {
     return `v.literal(${type.value})`;
   }
-  if (flags & ts.TypeFlags.BooleanLiteral) {
-    var name = type.intrinsicName;
-    return `v.literal(${name === "true"})`;
+  if (type.isBooleanLiteralType()) {
+    return `v.literal(${type.value})`;
   }
-  if (type.isUnion()) {
-    var members = type.types;
-    var hasNull = members.some(function (t) {
-      return t.getFlags() & ts.TypeFlags.Null;
+  if (type.isUnionType()) {
+    var members = await type.getTypes();
+    var hasNull = members.some(function (member) {
+      return member.flags & import_async.TypeFlags.Null;
     });
-    var hasUndefined = members.some(function (t) {
-      return t.getFlags() & (ts.TypeFlags.Undefined | ts.TypeFlags.Void);
+    var hasUndefined = members.some(function (member) {
+      return member.flags & (import_async.TypeFlags.Undefined | import_async.TypeFlags.Void);
     });
-    var rest = members.filter(function (t) {
-      return !(t.getFlags() & (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void));
+    var rest = members.filter(function (member) {
+      return !(member.flags & (import_async.TypeFlags.Null | import_async.TypeFlags.Undefined | import_async.TypeFlags.Void));
     });
-    if (rest.length === 2 && rest.every(function (t) {
-      return t.getFlags() & ts.TypeFlags.BooleanLiteral;
+    if (rest.length === 2 && rest.every(function (member) {
+      return member.flags & import_async.TypeFlags.BooleanLiteral;
     })) {
       var inner = "v.boolean()";
       if (hasNull) inner = `v.nullable(${inner})`;
@@ -610,52 +567,50 @@ function tsTypeToValibot(ts, checker, type, seen) {
       return inner;
     }
     if (rest.length === 0) return "v.unknown()";
-    var inner1 = rest.length === 1 ? recurse(rest[0]) : `v.union([${rest.map(function (t) {
-      return recurse(t);
-    }).join(", ")}])`;
+    var inner1 = rest.length === 1 ? await recurse(rest[0]) : `v.union([${(await Promise.all(rest.map(recurse))).join(", ")}])`;
     if (hasNull) inner1 = `v.nullable(${inner1})`;
     if (hasUndefined) inner1 = `v.optional(${inner1})`;
     return inner1;
   }
-  var resolveSymbolType = function resolveSymbolType2(parent, prop2) {
-    var _prop_declarations;
-    var instantiated = getInstantiatedPropertyType(checker, parent, prop2.getName());
-    if (instantiated) return instantiated;
-    if (prop2.valueDeclaration) return checker.getTypeOfSymbolAtLocation(prop2, prop2.valueDeclaration);
-    if ((_prop_declarations = prop2.declarations) === null || _prop_declarations === void 0 ? void 0 : _prop_declarations[0]) return checker.getTypeOfSymbolAtLocation(prop2, prop2.declarations[0]);
-    return checker.getDeclaredTypeOfSymbol(prop2);
+  var resolveSymbolType = async function resolveSymbolType2(property) {
+    var _property_valueDeclaration;
+    var symbolType = await checker.getTypeOfSymbol(property);
+    if (symbolType && !symbolType.isErrorType()) return symbolType;
+    var declaration = (_property_valueDeclaration = property.valueDeclaration) !== null && _property_valueDeclaration !== void 0 ? _property_valueDeclaration : property.declarations[0];
+    var node = declaration ? await declaration.resolve(project) : void 0;
+    if (node) return checker.getTypeOfSymbolAtLocation(property, node);
+    return checker.getDeclaredTypeOfSymbol(property);
   };
-  if (type.isIntersection()) {
-    var props = type.getProperties();
-    if (props.length === 0) return "v.object({})";
+  var objectToValibot = async function objectToValibot2(props2) {
+    if (props2.length === 0) return "v.object({})";
     var entries = [];
-    var _iteratorNormalCompletion = true,
-      _didIteratorError = false,
-      _iteratorError = void 0;
+    var _iteratorNormalCompletion2 = true,
+      _didIteratorError2 = false,
+      _iteratorError2 = void 0;
     try {
-      for (var _iterator = props[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var prop = _step.value;
-        var name1 = prop.getName();
-        if ((0, import_generate_helpers.shouldSkipObjectKey)(name1)) continue;
-        var propType = resolveSymbolType(type, prop);
-        var isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional);
-        var val = recurse(propType);
+      for (var _iterator2 = props2[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var prop = _step2.value;
+        var name = prop.name;
+        if ((0, import_generate_helpers.shouldSkipObjectKey)(name)) continue;
+        var propType = await resolveSymbolType(prop);
+        var isOptional = Boolean(prop.flags & import_async.SymbolFlags.Optional);
+        var val = await recurse(propType);
         if (isOptional && !val.startsWith("v.optional(")) {
           val = `v.optional(${val})`;
         }
-        entries.push(`${(0, import_generate_helpers.formatObjectKey)(name1)}: ${val}`);
+        entries.push(`${(0, import_generate_helpers.formatObjectKey)(name)}: ${val}`);
       }
     } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
     } finally {
       try {
-        if (!_iteratorNormalCompletion && _iterator.return != null) {
-          _iterator.return();
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
         }
       } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
+        if (_didIteratorError2) {
+          throw _iteratorError2;
         }
       }
     }
@@ -663,70 +618,51 @@ function tsTypeToValibot(ts, checker, type, seen) {
     return `v.object({
     ${entries.join(",\n    ")},
   })`;
+  };
+  if (type.isIntersectionType()) {
+    return objectToValibot(await checker.getPropertiesOfType(type));
   }
-  var props1 = type.getProperties();
-  if (props1.length > 0 && (type.getFlags() & ts.TypeFlags.Object || type.objectFlags)) {
-    var _type_objectFlags;
-    var objectFlags = (_type_objectFlags = type.objectFlags) !== null && _type_objectFlags !== void 0 ? _type_objectFlags : 0;
-    if (objectFlags & ts.ObjectFlags.Reference) {
-      var _typeRef_typeArguments;
-      var typeRef = type;
-      var symbol = type.getSymbol();
-      var name2 = symbol === null || symbol === void 0 ? void 0 : symbol.getName();
-      if ((name2 === "Array" || name2 === "ReadonlyArray") && ((_typeRef_typeArguments = typeRef.typeArguments) === null || _typeRef_typeArguments === void 0 ? void 0 : _typeRef_typeArguments.length) === 1) {
-        return `v.array(${recurse(typeRef.typeArguments[0])})`;
+  if (type.isTupleType()) {
+    var typeArgs1 = await checker.getTypeArguments(type);
+    return `v.tuple([${(await Promise.all(typeArgs1.map(recurse))).join(", ")}])`;
+  }
+  if (type.isObjectType()) {
+    if (type.objectFlags & import_async.ObjectFlags.Reference && type.isTypeReference()) {
+      var symbol = await type.getSymbol();
+      var typeArgs2 = await checker.getTypeArguments(type);
+      if (((symbol === null || symbol === void 0 ? void 0 : symbol.name) === "Array" || (symbol === null || symbol === void 0 ? void 0 : symbol.name) === "ReadonlyArray") && typeArgs2.length === 1) {
+        return `v.array(${await recurse(typeArgs2[0])})`;
       }
     }
-    if (objectFlags & ts.ObjectFlags.Tuple) {
-      var typeRef1 = type;
-      var typeArgs1 = typeRef1.typeArguments || [];
-      return `v.tuple([${typeArgs1.map(function (t) {
-        return recurse(t);
-      }).join(", ")}])`;
+    var props = await checker.getPropertiesOfType(type);
+    if (props.length > 0) return objectToValibot(props);
+  }
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = (await checker.getIndexInfosOfType(type))[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var indexInfo1 = _step.value;
+      if (indexInfo1.keyType.flags & import_async.TypeFlags.String) {
+        return `v.record(v.string(), ${await recurse(indexInfo1.valueType)})`;
+      }
+      if (indexInfo1.keyType.flags & import_async.TypeFlags.Number) {
+        return `v.record(v.number(), ${await recurse(indexInfo1.valueType)})`;
+      }
     }
-    var entries1 = [];
-    var _iteratorNormalCompletion1 = true,
-      _didIteratorError1 = false,
-      _iteratorError1 = void 0;
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
     try {
-      for (var _iterator1 = props1[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
-        var prop1 = _step1.value;
-        var name3 = prop1.getName();
-        if ((0, import_generate_helpers.shouldSkipObjectKey)(name3)) continue;
-        var propType1 = resolveSymbolType(type, prop1);
-        var isOptional1 = !!(prop1.getFlags() & ts.SymbolFlags.Optional);
-        var val1 = recurse(propType1);
-        if (isOptional1 && !val1.startsWith("v.optional(")) {
-          val1 = `v.optional(${val1})`;
-        }
-        entries1.push(`${(0, import_generate_helpers.formatObjectKey)(name3)}: ${val1}`);
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
       }
-    } catch (err) {
-      _didIteratorError1 = true;
-      _iteratorError1 = err;
     } finally {
-      try {
-        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-          _iterator1.return();
-        }
-      } finally {
-        if (_didIteratorError1) {
-          throw _iteratorError1;
-        }
+      if (_didIteratorError) {
+        throw _iteratorError;
       }
     }
-    if (entries1.length === 0) return "v.object({})";
-    return `v.object({
-    ${entries1.join(",\n    ")},
-  })`;
-  }
-  var stringIndex = type.getStringIndexType();
-  if (stringIndex) {
-    return `v.record(v.string(), ${recurse(stringIndex)})`;
-  }
-  var numberIndex = type.getNumberIndexType();
-  if (numberIndex) {
-    return `v.record(v.number(), ${recurse(numberIndex)})`;
   }
   return "v.unknown()";
 }
@@ -882,16 +818,33 @@ function dataMembershipFromLayout(layout) {
     }))].sort()
   };
 }
+async function loadGeneratorProject(baseDir) {
+  var sourcePaths = (0, import_native_typescript.collectTypeScriptSourcePaths)([baseDir, (0, import_path.resolve)((0, import_path.dirname)(baseDir), "database")]);
+  return (0, import_native_typescript.createNativeTypeScriptProject)(baseDir, sourcePaths);
+}
 async function deriveDataMembership(options) {
-  var ts = await import("typescript");
-  var layout = (0, import_generate_layout.discoverDataLayout)(ts, (0, import_path.resolve)(options.dir), options.config ? (0, import_path.resolve)(options.config) : void 0);
-  return dataMembershipFromLayout(layout);
+  var baseDir = (0, import_path.resolve)(options.dir);
+  var project = await loadGeneratorProject(baseDir);
+  try {
+    var layout = (0, import_generate_layout.discoverDataLayout)(project, baseDir, options.config ? (0, import_path.resolve)(options.config) : void 0);
+    return dataMembershipFromLayout(layout);
+  } finally {
+    await project.close();
+  }
 }
 async function generateDrizzleSchemaInputFile(options) {
+  var baseDir = (0, import_path.resolve)(options.dir);
+  var project = await loadGeneratorProject(baseDir);
+  try {
+    return generateDrizzleSchemaInputFileWithProject(options, project);
+  } finally {
+    await project.close();
+  }
+}
+async function generateDrizzleSchemaInputFileWithProject(options, project) {
   var _layout_metadataPaths_find;
-  var ts = await import("typescript");
   var baseDir = (0, import_path.resolve)(options.dir);
-  var layout = (0, import_generate_layout.discoverDataLayout)(ts, baseDir, options.config ? (0, import_path.resolve)(options.config) : void 0);
+  var layout = (0, import_generate_layout.discoverDataLayout)(project, baseDir, options.config ? (0, import_path.resolve)(options.config) : void 0);
   var tableNames = dataMembershipFromLayout(layout).allTables;
   var relationsPath = (_layout_metadataPaths_find = layout.metadataPaths.find(function (path) {
     return (0, import_path.basename)(path) === "relations.ts" && (0, import_path.dirname)(path) === (0, import_path.resolve)((0, import_path.dirname)(baseDir), "database");
@@ -900,11 +853,11 @@ async function generateDrizzleSchemaInputFile(options) {
   });
   var relationEntries = [];
   if (relationsPath) {
-    var source = ts.createSourceFile(relationsPath, (0, import_fs.readFileSync)(relationsPath, "utf8"), ts.ScriptTarget.Latest, true);
+    var source = project.sourceFile(relationsPath);
     var included = new Set(tableNames);
     var visit = function visit1(node) {
       if (!ts.isCallExpression(node) || node.expression.getText(source) !== "defineRelations") {
-        ts.forEachChild(node, visit);
+        node.forEachChild(visit);
         return;
       }
       var factory = node.arguments[1];
@@ -978,6 +931,14 @@ ${relations.map(function (relation) {
   return ["// auto-generated from the on-zero data layout", `import { defineRelations } from 'drizzle-orm'`, `import * as schema from ${schemaImportPath}`, "", `export { ${tableNames.join(", ")} } from ${schemaImportPath}`, `export const relations = defineRelations(schema, (r) => ({`, ...relationEntries, `}))`, ""].join("\n");
 }
 async function generate(options) {
+  var project = await loadGeneratorProject((0, import_path.resolve)(options.dir));
+  try {
+    return await generateWithProject(options, project);
+  } finally {
+    await project.close();
+  }
+}
+async function generateWithProject(options, project) {
   var {
     dir,
     after,
@@ -993,13 +954,44 @@ async function generate(options) {
     });
   }
   loadCache();
-  var ts = await import("typescript");
-  var layout = (0, import_generate_layout.discoverDataLayout)(ts, baseDir, config ? (0, import_path.resolve)(config) : void 0);
+  var layout = (0, import_generate_layout.discoverDataLayout)(project, baseDir, config ? (0, import_path.resolve)(config) : void 0);
   var metadataHash = hash(layout.metadataPaths.map(function (path) {
     return `${path}\0${(0, import_fs.readFileSync)(path, "utf8")}`;
   }).join("\0"));
+  var databaseSchemaPath = (0, import_path.resolve)((0, import_path.dirname)(baseDir), "database/schema.ts");
+  var needsSqliteZeroSchema = (0, import_fs.existsSync)(databaseSchemaPath);
   var inputHash = hash(`${hashInputTree(layout.sourceRoots, generatedDir)}\0${metadataHash}`);
-  if (!force && generateCache.__generatorVersion === GENERATOR_CACHE_VERSION && generateCache.__inputHash === inputHash && (0, import_fs.existsSync)((0, import_path.resolve)(generatedDir, "models.ts"))) {
+  if (!force && generateCache.__generatorVersion === GENERATOR_CACHE_VERSION && generateCache.__inputHash === inputHash &&
+  // the input hash deliberately skips the generated directory, so it cannot
+  // notice that the outputs themselves moved. existence is not correctness
+  // either: a checkout, merge or revert leaves every file present and stale.
+  // confirm the bytes on disk still match what the cache says it wrote there
+  // before skipping the build, or the fast path serves someone else's output.
+  //
+  // a consumer that formats generated output after this runs never hits the
+  // fast path again, because the cache holds the bytes written here and disk
+  // holds the formatted ones. soot does exactly that, `on-zero generate &&
+  // generate-instance-tables && oxfmt src/data/generated/`, and the number is
+  // already taken: 2.50s median before, 3.69s after, four warm runs each in
+  // one checkout with only the pin swapped, so about 1.2 seconds or 47
+  // percent on this step. the full three-command script went 2.65s to 3.14s
+  // with a spread that swallows most of it.
+  //
+  // the shape matters more than the number. this is not a cache that hits
+  // less often, it is a cache that never hits, so the cost does not degrade
+  // gracefully and grows with the generated output rather than staying at
+  // 1.2s. correct and slower beats fast and stale, which is why it is written
+  // this way, but if generate time ever becomes the complaint, record the
+  // hash after the consumer's formatter runs rather than weakening this.
+  Object.entries(generateCache).every(function (param) {
+    var [cachedPath, cachedHash] = param;
+    if (!cachedPath.startsWith(generatedDir)) return true;
+    try {
+      return hash((0, import_fs.readFileSync)(cachedPath, "utf-8")) === cachedHash;
+    } catch (unused) {
+      return false;
+    }
+  }) && (0, import_fs.existsSync)((0, import_path.resolve)(generatedDir, "models.ts")) && (!needsSqliteZeroSchema || (0, import_fs.existsSync)((0, import_path.resolve)(generatedDir, "schema.ts")))) {
     var _counts_modelCount, _counts_schemaCount, _counts_queryCount, _counts_mutationCount;
     var counts = {};
     try {
@@ -1039,6 +1031,24 @@ async function generate(options) {
     return module2.name;
   }))), writeFileIfChanged((0, import_path.resolve)(generatedDir, "tables.ts"), (0, import_generate_helpers.generateTablesFile)(schemaModules))] : []), writeFileIfChanged((0, import_path.resolve)(generatedDir, "README.md"), (0, import_generate_helpers.generateReadmeFile)())];
   var filesChanged = writeResults.filter(Boolean).length;
+  if (needsSqliteZeroSchema) {
+    var membership = dataMembershipFromLayout(layout);
+    var drizzleSchema = await generateDrizzleSchemaInputFileWithProject({
+      dir: baseDir,
+      schemaImportPath: "../../database/schema",
+      config
+    }, project);
+    var sqliteSchema = (0, import_generate_helpers.renderDrizzleZeroSqliteSchemaModule)({
+      importPath: "./drizzleSchema",
+      tableNames: membership.allTables
+    });
+    if (writeFileIfChanged((0, import_path.resolve)(generatedDir, "drizzleSchema.ts"), drizzleSchema)) {
+      filesChanged++;
+    }
+    if (writeFileIfChanged((0, import_path.resolve)(generatedDir, "schema.ts"), sqliteSchema)) {
+      filesChanged++;
+    }
+  }
   var queryCount = 0;
   var mutationCount = 0;
   var typeToValibot = function typeToValibot2(paramType) {
@@ -1049,32 +1059,17 @@ async function generate(options) {
     }
   };
   var allQueries = [];
-  var queryResolver = null;
-  var getQueryResolver = function getQueryResolver2() {
-    if (!queryResolver) {
-      var allFiles2 = [...new Set(layout.namespaces.flatMap(function (namespace2) {
-        return namespace2.sourcePaths;
-      }))].map(function (path) {
-        return {
-          path,
-          content: (0, import_fs.readFileSync)(path, "utf-8")
-        };
-      });
-      queryResolver = createTypeResolver(ts, allFiles2, baseDir);
-    }
-    return queryResolver;
-  };
   var _iteratorNormalCompletion = true,
     _didIteratorError = false,
     _iteratorError = void 0;
   try {
-    var _loop = function () {
+    var _loop = async function () {
       var namespace2 = _step.value;
       var filePath2 = namespace2.queryPath;
       try {
-        var content2 = (0, import_fs.readFileSync)(filePath2, "utf-8");
-        var sourceFile2 = ts.createSourceFile(filePath2, content2, ts.ScriptTarget.Latest, true);
-        ts.forEachChild(sourceFile2, function (node) {
+        var sourceFile2 = project.sourceFile(filePath2);
+        var candidates = [];
+        sourceFile2.forEachChild(function (node) {
           if (ts.isVariableStatement(node)) {
             var _node_modifiers;
             var exportModifier = (_node_modifiers = node.modifiers) === null || _node_modifiers === void 0 ? void 0 : _node_modifiers.find(function (m) {
@@ -1086,6 +1081,8 @@ async function generate(options) {
             var name = declaration.name.getText(sourceFile2);
             if (["mutate", "permission", "schema", "where"].includes(name)) return;
             if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
+              var _ref;
+              var _params_;
               var params = declaration.initializer.parameters;
               var paramType = "void";
               if (params.length > 0) {
@@ -1093,38 +1090,59 @@ async function generate(options) {
                 var param = params[0];
                 paramType = ((_param_type = param.type) === null || _param_type === void 0 ? void 0 : _param_type.getText(sourceFile2)) || "unknown";
               }
-              var valibotCode = typeToValibot(paramType);
-              if (!valibotCode && params.length > 0 && params[0].type) {
-                var resolver = getQueryResolver();
-                var resolverSourceFile = resolver.program.getSourceFile(filePath2);
-                if (resolverSourceFile) {
-                  var resolvedType = resolveParamType(ts, resolver, resolverSourceFile, name, 0);
-                  if (resolvedType) {
-                    valibotCode = resolver.typeToValibot(resolvedType);
-                  }
-                }
-              }
-              if (valibotCode) {
-                allQueries.push({
-                  name,
-                  params: paramType,
-                  valibotCode,
-                  sourceFile: namespace2.name,
-                  importPath: (0, import_generate_layout.namespaceImportPath)(baseDir, filePath2)
-                });
-              } else if (!silent && paramType !== "void") {
-                console.error(`\u2717 ${name}: could not resolve type "${paramType}"`);
-              }
+              candidates.push({
+                name,
+                paramType,
+                typeNode: (_ref = (_params_ = params[0]) === null || _params_ === void 0 ? void 0 : _params_.type) !== null && _ref !== void 0 ? _ref : null
+              });
             }
           }
         });
+        var resolver = createTypeResolver(project.projectForFile(filePath2));
+        var _iteratorNormalCompletion4 = true,
+          _didIteratorError4 = false,
+          _iteratorError4 = void 0;
+        try {
+          for (var _iterator4 = candidates[Symbol.iterator](), _step12; !(_iteratorNormalCompletion4 = (_step12 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+            var candidate = _step12.value;
+            var valibotCode = typeToValibot(candidate.paramType);
+            if (!valibotCode && candidate.typeNode) {
+              var resolvedType = await resolveParamType(resolver, sourceFile2, candidate.name, 0);
+              if (resolvedType) valibotCode = await resolver.typeToValibot(resolvedType);
+            }
+            if (valibotCode) {
+              allQueries.push({
+                name: candidate.name,
+                params: candidate.paramType,
+                valibotCode,
+                sourceFile: namespace2.name,
+                importPath: (0, import_generate_layout.namespaceImportPath)(baseDir, filePath2)
+              });
+            } else if (!silent && candidate.paramType !== "void") {
+              console.error(`\u2717 ${candidate.name}: could not resolve type "${candidate.paramType}"`);
+            }
+          }
+        } catch (err) {
+          _didIteratorError4 = true;
+          _iteratorError4 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+              _iterator4.return();
+            }
+          } finally {
+            if (_didIteratorError4) {
+              throw _iteratorError4;
+            }
+          }
+        }
       } catch (err) {
         if (!silent) console.error(`Error processing ${filePath2}:`, err);
       }
     };
     for (var _iterator = layout.namespaces.filter(function (namespace2) {
         return namespace2.queryPath !== null;
-      })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
+      })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) await _loop();
   } catch (err) {
     _didIteratorError = true;
     _iteratorError = err;
@@ -1179,7 +1197,6 @@ async function generate(options) {
     if (aggregatesChanged) filesChanged++;
   }
   var allModelMutations = [];
-  var mutationFiles = [];
   var unresolvedModels = [];
   var _iteratorNormalCompletion1 = true,
     _didIteratorError1 = false,
@@ -1191,13 +1208,8 @@ async function generate(options) {
       var fileBaseName = namespace.name;
       try {
         var content = (0, import_fs.readFileSync)(filePath, "utf-8");
-        mutationFiles.push({
-          path: filePath,
-          content,
-          baseName: fileBaseName
-        });
-        var sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-        var result = extractMutationsFromModel(ts, sourceFile, content, filePath, !!silent, typeToValibot);
+        var sourceFile = project.sourceFile(filePath);
+        var result = extractMutationsFromModel(sourceFile, content, filePath, !!silent, typeToValibot);
         if (result) {
           result.modelName = fileBaseName;
           allModelMutations.push(result);
@@ -1230,62 +1242,44 @@ async function generate(options) {
     }
   }
   if (unresolvedModels.length > 0) {
-    var collectTsFiles = function collectTsFiles1(dir2) {
-      var results = [];
-      var _iteratorNormalCompletion4 = true,
-        _didIteratorError4 = false,
-        _iteratorError4 = void 0;
-      try {
-        for (var _iterator4 = (0, import_fs.readdirSync)(dir2, {
-            withFileTypes: true
-          })[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-          var entry = _step4.value;
-          var fullPath = (0, import_path.resolve)(dir2, entry.name);
-          if (entry.isDirectory() && entry.name !== "node_modules") {
-            results.push(...collectTsFiles(fullPath));
-          } else if (entry.isFile() && isGeneratorSourceFile(entry.name)) {
-            results.push({
-              path: fullPath,
-              content: (0, import_fs.readFileSync)(fullPath, "utf-8")
-            });
-          }
-        }
-      } catch (err) {
-        _didIteratorError4 = true;
-        _iteratorError4 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-            _iterator4.return();
-          }
-        } finally {
-          if (_didIteratorError4) {
-            throw _iteratorError4;
-          }
-        }
-      }
-      return results;
-    };
-    var allFiles = [...new Map(layout.sourceRoots.flatMap(collectTsFiles).map(function (file) {
-      return [file.path, file];
-    })).values()];
-    var modelResolver = createTypeResolver(ts, allFiles, baseDir);
     var _iteratorNormalCompletion2 = true,
       _didIteratorError2 = false,
       _iteratorError2 = void 0;
     try {
-      var _loop1 = function () {
+      var _loop1 = async function () {
         var {
           baseName,
           filePath: filePath2
         } = _step2.value;
-        var resolverSourceFile = modelResolver.program.getSourceFile(filePath2);
-        if (!resolverSourceFile) return "continue";
-        var resolvedTypes = resolveMutationParamTypes(ts, modelResolver, resolverSourceFile);
+        var sourceFile2 = project.sourceFile(filePath2);
+        var modelResolver = createTypeResolver(project.projectForFile(filePath2));
+        var resolvedTypes = await resolveMutationParamTypes(modelResolver, sourceFile2);
         if (resolvedTypes.size === 0) return "continue";
+        var resolvedValibot = /* @__PURE__ */new Map();
+        var _iteratorNormalCompletion4 = true,
+          _didIteratorError4 = false,
+          _iteratorError4 = void 0;
+        try {
+          for (var _iterator4 = resolvedTypes[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+            var [name, type] = _step4.value;
+            resolvedValibot.set(name, await modelResolver.typeToValibot(type));
+          }
+        } catch (err) {
+          _didIteratorError4 = true;
+          _iteratorError4 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+              _iterator4.return();
+            }
+          } finally {
+            if (_didIteratorError4) {
+              throw _iteratorError4;
+            }
+          }
+        }
         var content2 = (0, import_fs.readFileSync)(filePath2, "utf-8");
-        var sourceFile2 = ts.createSourceFile(filePath2, content2, ts.ScriptTarget.Latest, true);
-        var result2 = extractMutationsFromModel(ts, sourceFile2, content2, filePath2, !!silent, typeToValibot, resolvedTypes, modelResolver.typeToValibot);
+        var result2 = extractMutationsFromModel(sourceFile2, content2, filePath2, !!silent, typeToValibot, resolvedValibot);
         if (result2) {
           result2.modelName = baseName;
           var idx = allModelMutations.findIndex(function (m) {
@@ -1294,7 +1288,7 @@ async function generate(options) {
           if (idx >= 0) allModelMutations[idx] = result2;
         }
       };
-      for (var _iterator2 = unresolvedModels[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) _loop1();
+      for (var _iterator2 = unresolvedModels[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) await _loop1();
     } catch (err) {
       _didIteratorError2 = true;
       _iteratorError2 = err;
@@ -1404,8 +1398,13 @@ ${event} ${path}`);
     }, debounce);
   };
   var databaseDir = (0, import_path.resolve)((0, import_path.dirname)(baseDir), "database");
-  var ts = await import("typescript");
-  var layout = (0, import_generate_layout.discoverDataLayout)(ts, baseDir, options.config ? (0, import_path.resolve)(options.config) : void 0);
+  var project = await loadGeneratorProject(baseDir);
+  var layout;
+  try {
+    layout = (0, import_generate_layout.discoverDataLayout)(project, baseDir, options.config ? (0, import_path.resolve)(options.config) : void 0);
+  } finally {
+    await project.close();
+  }
   var watcher = chokidar.watch([... /* @__PURE__ */new Set([...layout.sourceRoots, ...((0, import_fs.existsSync)(databaseDir) ? [databaseDir] : [])])], {
     persistent: true,
     ignoreInitial: true,