on-zero 0.16.17 → 0.16.19

package/dist/esm/generate.mjs

@@ -1,10 +1,13 @@
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { basename, dirname, resolve } from "node:path";
-import { CRUD_MUTATION_NAMES, formatObjectKey, generateAggregatesFile, generateGroupedQueriesFile, generateInstancesFile, generateModelsFile, generateReadmeFile, generateSyncedMutationsFile, generateSyncedQueriesFile, generateTablesFile, generateTypesFile, parseColumnType, parseTypeString, shouldSkipObjectKey } from "./generate-helpers.mjs";
+import * as ts from "typescript/unstable/ast";
+import { ObjectFlags, SymbolFlags, TypeFlags } from "typescript/unstable/async";
+import { CRUD_MUTATION_NAMES, formatObjectKey, generateAggregatesFile, generateGroupedQueriesFile, generateInstancesFile, generateModelsFile, generateReadmeFile, generateSyncedMutationsFile, generateSyncedQueriesFile, generateTablesFile, generateTypesFile, parseColumnType, parseTypeString, renderDrizzleZeroSqliteSchemaModule, shouldSkipObjectKey } from "./generate-helpers.mjs";
 import { discoverDataLayout, namespaceImportPath } from "./generate-layout.mjs";
+import { collectTypeScriptSourcePaths, createNativeTypeScriptProject } from "./native-typescript.mjs";
 const hash = s => createHash("sha256").update(s).digest("hex");
-const GENERATOR_CACHE_VERSION = "6";
+const GENERATOR_CACHE_VERSION = "7";
 const isGeneratorSourceFile = name => name.endsWith(".ts") && !name.endsWith(".d.ts") && !name.endsWith(".test.ts") && !name.endsWith(".spec.ts");
 function hashInputTree(sourceRoots, generatedDir) {
   const parts = [];
@@ -65,72 +68,37 @@ function saveCache() {
 }
 function writeFileIfChanged(filePath, content) {
   const contentHash = hash(content);
-  const cachedHash = generateCache[filePath];
-  if (cachedHash === contentHash && existsSync(filePath)) {
+  let onDisk = null;
+  try {
+    onDisk = readFileSync(filePath, "utf-8");
+  } catch {}
+  if (onDisk !== null && hash(onDisk) === contentHash) {
+    generateCache[filePath] = contentHash;
     return false;
   }
   writeFileSync(filePath, content, "utf-8");
   generateCache[filePath] = contentHash;
   return true;
 }
-function createTypeResolver(ts, files, dir) {
-  const configPath = ts.findConfigFile(dir, ts.sys.fileExists, "tsconfig.json");
-  let compilerOptions = {
-    target: ts.ScriptTarget.Latest,
-    module: ts.ModuleKind.ESNext,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    strict: false,
-    skipLibCheck: true,
-    noEmit: true
-  };
-  if (configPath) {
-    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    if (configFile.config) {
-      const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, dirname(configPath));
-      compilerOptions = {
-        ...compilerOptions,
-        ...parsed.options
-      };
-    }
-  }
-  const fileMap = /* @__PURE__ */new Map();
-  for (const f of files) {
-    fileMap.set(f.path, f.content);
-  }
-  const host = ts.createCompilerHost(compilerOptions);
-  const originalGetSourceFile = host.getSourceFile.bind(host);
-  host.getSourceFile = (fileName, languageVersion, onError) => {
-    const content = fileMap.get(fileName);
-    if (content !== void 0) {
-      return ts.createSourceFile(fileName, content, languageVersion, true);
-    }
-    return originalGetSourceFile(fileName, languageVersion, onError);
-  };
-  host.fileExists = fileName => fileMap.has(fileName) || ts.sys.fileExists(fileName);
-  host.readFile = fileName => fileMap.get(fileName) ?? ts.sys.readFile(fileName);
-  const program = ts.createProgram(files.map(f => f.path), compilerOptions, host);
-  const 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);
+        return (await project.checker.getTypeFromTypeNode(node)) ?? null;
       } catch {
         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) {
-  let result = null;
-  ts.forEachChild(sourceFile, node => {
-    if (result) return;
+async function resolveParamType(resolver, sourceFile, exportName, paramIndex) {
+  let typeNode = null;
+  sourceFile.forEachChild(node => {
+    if (typeNode) return;
     if (!ts.isVariableStatement(node)) return;
     if (!node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
     const decl = node.declarationList.declarations[0];
@@ -139,13 +107,13 @@ function resolveParamType(ts, resolver, sourceFile, exportName, paramIndex) {
     if (decl.initializer && ts.isArrowFunction(decl.initializer)) {
       const param = decl.initializer.parameters[paramIndex];
       if (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) {
   const args = call.arguments;
   if (args.length < 2) {
     const only = args[0];
@@ -171,9 +139,9 @@ function readMutationsCall(ts, call) {
     handlersArg: handlers && ts.isObjectLiteralExpression(handlers) ? handlers : null
   };
 }
-function resolveMutationParamTypes(ts, resolver, sourceFile) {
-  const resolved = /* @__PURE__ */new Map();
-  ts.forEachChild(sourceFile, node => {
+async function resolveMutationParamTypes(resolver, sourceFile) {
+  const nodes = /* @__PURE__ */new Map();
+  sourceFile.forEachChild(node => {
     if (!ts.isVariableStatement(node)) return;
     if (!node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
     const decl = node.declarationList.declarations[0];
@@ -182,7 +150,7 @@ function resolveMutationParamTypes(ts, resolver, sourceFile) {
     if (!decl.initializer || !ts.isCallExpression(decl.initializer)) return;
     const {
       handlersArg
-    } = readMutationsCall(ts, decl.initializer);
+    } = readMutationsCall(decl.initializer);
     if (!handlersArg) return;
     for (const prop of handlersArg.properties) {
       if (!ts.isPropertyAssignment(prop) && !ts.isMethodDeclaration(prop)) continue;
@@ -200,17 +168,19 @@ function resolveMutationParamTypes(ts, resolver, sourceFile) {
       if (!params || params.length < 2) continue;
       const typeNode = params[1].type;
       if (!typeNode) continue;
-      const expanded = resolver.resolveType(typeNode);
-      if (expanded) {
-        resolved.set(name, expanded);
-      }
+      nodes.set(name, typeNode);
     }
   });
+  const resolved = /* @__PURE__ */new Map();
+  for (const [name, node] of nodes) {
+    const expanded = await resolver.resolveType(node);
+    if (expanded) resolved.set(name, expanded);
+  }
   return resolved;
 }
-function extractMutationsFromModel(ts, sourceFile, content, fileName, silent, typeToValibot, resolvedTypes, resolvedTypeToValibot) {
+function extractMutationsFromModel(sourceFile, content, fileName, silent, typeToValibot, resolvedValibot) {
   let mutateNode = null;
-  ts.forEachChild(sourceFile, node => {
+  sourceFile.forEachChild(node => {
     if (!ts.isVariableStatement(node)) return;
     if (!node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
     const decl = node.declarationList.declarations[0];
@@ -234,12 +204,12 @@ function extractMutationsFromModel(ts, sourceFile, content, fileName, silent, ty
     hasTable,
     crud,
     handlersArg
-  } = readMutationsCall(ts, call);
+  } = readMutationsCall(call);
   const hasCRUD = hasTable && crud;
   const columns = {};
   const primaryKeys = [];
   if (hasCRUD) {
-    extractSchemaColumns(ts, sourceFile, columns, primaryKeys);
+    extractSchemaColumns(sourceFile, columns, primaryKeys);
   }
   const custom = [];
   if (handlersArg) {
@@ -276,11 +246,8 @@ function extractMutationsFromModel(ts, sourceFile, content, fileName, silent, ty
         continue;
       }
       let valibotCode = typeToValibot(paramType);
-      if (!valibotCode && resolvedTypes && resolvedTypeToValibot) {
-        const resolvedType = resolvedTypes.get(name);
-        if (resolvedType) {
-          valibotCode = resolvedTypeToValibot(resolvedType);
-        }
+      if (!valibotCode && resolvedValibot) {
+        valibotCode = resolvedValibot.get(name) ?? null;
       }
       custom.push({
         name,
@@ -297,7 +264,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)) {
       const text = node.expression.getText(sourceFile);
@@ -322,80 +289,75 @@ function extractSchemaColumns(ts, sourceFile, columns, primaryKeys) {
         }
       }
     }
-    ts.forEachChild(node, visit);
+    node.forEachChild(visit);
   }
   visit(sourceFile);
 }
-function getInstantiatedPropertyType(checker, parent, name) {
-  const 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) {
-  if (!seen) seen = /* @__PURE__ */new Set();
-  const flags = type.getFlags();
-  if (flags & (ts.TypeFlags.Object | ts.TypeFlags.Intersection)) {
-    if (seen.has(type)) return "v.unknown()";
-    seen.add(type);
-  }
-  const recurse = t => tsTypeToValibot(ts, checker, t, 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?.(type) || checker.isArrayLikeType?.(type))) {
-    const typeArgs = checker.getTypeArguments?.(type) ?? [];
-    const elementType = typeArgs.length === 1 ? typeArgs[0] : type.getNumberIndexType?.();
-    return `v.array(${elementType ? recurse(elementType) : "v.unknown()"})`;
-  }
-  if (flags & ts.TypeFlags.StringLiteral) {
+async function tsTypeToValibot(project, type, seen = /* @__PURE__ */new Set()) {
+  const checker = project.checker;
+  const flags = type.flags;
+  if (flags & (TypeFlags.Object | TypeFlags.Intersection)) {
+    if (seen.has(type.id)) return "v.unknown()";
+    seen.add(type.id);
+  }
+  const recurse = value => tsTypeToValibot(project, value, seen);
+  if (flags & TypeFlags.String) return "v.string()";
+  if (flags & TypeFlags.Number) return "v.number()";
+  if (flags & TypeFlags.Boolean) return "v.boolean()";
+  if (flags & TypeFlags.Void || flags & TypeFlags.Undefined) return "v.void_()";
+  if (flags & TypeFlags.Null) return "v.null_()";
+  if (flags & TypeFlags.Any || flags & TypeFlags.Unknown) return "v.unknown()";
+  if (flags & TypeFlags.Never) return "v.never()";
+  if (flags & TypeFlags.TemplateLiteral) return "v.string()";
+  if (flags & TypeFlags.Object && (await checker.isArrayLikeType(type))) {
+    const typeArgs = type.isTypeReference() ? await checker.getTypeArguments(type) : [];
+    const indexInfo = (await checker.getIndexInfosOfType(type)).find(info => Boolean(info.keyType.flags & TypeFlags.Number));
+    const elementType = typeArgs.length === 1 ? typeArgs[0] : indexInfo?.valueType;
+    return `v.array(${elementType ? await recurse(elementType) : "v.unknown()"})`;
+  }
+  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) {
-    const name = type.intrinsicName;
-    return `v.literal(${name === "true"})`;
+  if (type.isBooleanLiteralType()) {
+    return `v.literal(${type.value})`;
   }
-  if (type.isUnion()) {
-    const members = type.types;
-    const hasNull = members.some(t => t.getFlags() & ts.TypeFlags.Null);
-    const hasUndefined = members.some(t => t.getFlags() & (ts.TypeFlags.Undefined | ts.TypeFlags.Void));
-    const rest = members.filter(t => !(t.getFlags() & (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void)));
-    if (rest.length === 2 && rest.every(t => t.getFlags() & ts.TypeFlags.BooleanLiteral)) {
+  if (type.isUnionType()) {
+    const members = await type.getTypes();
+    const hasNull = members.some(member => member.flags & TypeFlags.Null);
+    const hasUndefined = members.some(member => member.flags & (TypeFlags.Undefined | TypeFlags.Void));
+    const rest = members.filter(member => !(member.flags & (TypeFlags.Null | TypeFlags.Undefined | TypeFlags.Void)));
+    if (rest.length === 2 && rest.every(member => member.flags & TypeFlags.BooleanLiteral)) {
       let inner2 = "v.boolean()";
       if (hasNull) inner2 = `v.nullable(${inner2})`;
       if (hasUndefined) inner2 = `v.optional(${inner2})`;
       return inner2;
     }
     if (rest.length === 0) return "v.unknown()";
-    let inner = rest.length === 1 ? recurse(rest[0]) : `v.union([${rest.map(t => recurse(t)).join(", ")}])`;
+    let inner = rest.length === 1 ? await recurse(rest[0]) : `v.union([${(await Promise.all(rest.map(recurse))).join(", ")}])`;
     if (hasNull) inner = `v.nullable(${inner})`;
     if (hasUndefined) inner = `v.optional(${inner})`;
     return inner;
   }
-  const resolveSymbolType = (parent, prop) => {
-    const instantiated = getInstantiatedPropertyType(checker, parent, prop.getName());
-    if (instantiated) return instantiated;
-    if (prop.valueDeclaration) return checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
-    if (prop.declarations?.[0]) return checker.getTypeOfSymbolAtLocation(prop, prop.declarations[0]);
-    return checker.getDeclaredTypeOfSymbol(prop);
+  const resolveSymbolType = async property => {
+    const symbolType = await checker.getTypeOfSymbol(property);
+    if (symbolType && !symbolType.isErrorType()) return symbolType;
+    const declaration = property.valueDeclaration ?? property.declarations[0];
+    const node = declaration ? await declaration.resolve(project) : void 0;
+    if (node) return checker.getTypeOfSymbolAtLocation(property, node);
+    return checker.getDeclaredTypeOfSymbol(property);
   };
-  if (type.isIntersection()) {
-    const props2 = type.getProperties();
-    if (props2.length === 0) return "v.object({})";
+  const objectToValibot = async props => {
+    if (props.length === 0) return "v.object({})";
     const entries = [];
-    for (const prop of props2) {
-      const name = prop.getName();
+    for (const prop of props) {
+      const name = prop.name;
       if (shouldSkipObjectKey(name)) continue;
-      const propType = resolveSymbolType(type, prop);
-      const isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional);
-      let val = recurse(propType);
+      const propType = await resolveSymbolType(prop);
+      const isOptional = Boolean(prop.flags & SymbolFlags.Optional);
+      let val = await recurse(propType);
       if (isOptional && !val.startsWith("v.optional(")) {
         val = `v.optional(${val})`;
       }
@@ -405,47 +367,32 @@ function tsTypeToValibot(ts, checker, type, seen) {
     return `v.object({
     ${entries.join(",\n    ")},
   })`;
-  }
-  const props = type.getProperties();
-  if (props.length > 0 && (type.getFlags() & ts.TypeFlags.Object || type.objectFlags)) {
-    const objectFlags = type.objectFlags ?? 0;
-    if (objectFlags & ts.ObjectFlags.Reference) {
-      const typeRef = type;
-      const symbol = type.getSymbol();
-      const name = symbol?.getName();
-      if ((name === "Array" || name === "ReadonlyArray") && typeRef.typeArguments?.length === 1) {
-        return `v.array(${recurse(typeRef.typeArguments[0])})`;
+  };
+  if (type.isIntersectionType()) {
+    return objectToValibot(await checker.getPropertiesOfType(type));
+  }
+  if (type.isTupleType()) {
+    const typeArgs = await checker.getTypeArguments(type);
+    return `v.tuple([${(await Promise.all(typeArgs.map(recurse))).join(", ")}])`;
+  }
+  if (type.isObjectType()) {
+    if (type.objectFlags & ObjectFlags.Reference && type.isTypeReference()) {
+      const symbol = await type.getSymbol();
+      const typeArgs = await checker.getTypeArguments(type);
+      if ((symbol?.name === "Array" || symbol?.name === "ReadonlyArray") && typeArgs.length === 1) {
+        return `v.array(${await recurse(typeArgs[0])})`;
       }
     }
-    if (objectFlags & ts.ObjectFlags.Tuple) {
-      const typeRef = type;
-      const typeArgs = typeRef.typeArguments || [];
-      return `v.tuple([${typeArgs.map(t => recurse(t)).join(", ")}])`;
+    const props = await checker.getPropertiesOfType(type);
+    if (props.length > 0) return objectToValibot(props);
+  }
+  for (const indexInfo of await checker.getIndexInfosOfType(type)) {
+    if (indexInfo.keyType.flags & TypeFlags.String) {
+      return `v.record(v.string(), ${await recurse(indexInfo.valueType)})`;
     }
-    const entries = [];
-    for (const prop of props) {
-      const name = prop.getName();
-      if (shouldSkipObjectKey(name)) continue;
-      const propType = resolveSymbolType(type, prop);
-      const isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional);
-      let val = recurse(propType);
-      if (isOptional && !val.startsWith("v.optional(")) {
-        val = `v.optional(${val})`;
-      }
-      entries.push(`${formatObjectKey(name)}: ${val}`);
+    if (indexInfo.keyType.flags & TypeFlags.Number) {
+      return `v.record(v.number(), ${await recurse(indexInfo.valueType)})`;
     }
-    if (entries.length === 0) return "v.object({})";
-    return `v.object({
-    ${entries.join(",\n    ")},
-  })`;
-  }
-  const stringIndex = type.getStringIndexType();
-  if (stringIndex) {
-    return `v.record(v.string(), ${recurse(stringIndex)})`;
-  }
-  const numberIndex = type.getNumberIndexType();
-  if (numberIndex) {
-    return `v.record(v.number(), ${recurse(numberIndex)})`;
   }
   return "v.unknown()";
 }
@@ -536,24 +483,41 @@ function dataMembershipFromLayout(layout) {
     allTables: [...new Set(layout.instances.flatMap(instance => [...instance.syncTables, ...instance.supportTables]))].sort()
   };
 }
+async function loadGeneratorProject(baseDir) {
+  const sourcePaths = collectTypeScriptSourcePaths([baseDir, resolve(dirname(baseDir), "database")]);
+  return createNativeTypeScriptProject(baseDir, sourcePaths);
+}
 async function deriveDataMembership(options) {
-  const ts = await import("typescript");
-  const layout = discoverDataLayout(ts, resolve(options.dir), options.config ? resolve(options.config) : void 0);
-  return dataMembershipFromLayout(layout);
+  const baseDir = resolve(options.dir);
+  const project = await loadGeneratorProject(baseDir);
+  try {
+    const layout = discoverDataLayout(project, baseDir, options.config ? resolve(options.config) : void 0);
+    return dataMembershipFromLayout(layout);
+  } finally {
+    await project.close();
+  }
 }
 async function generateDrizzleSchemaInputFile(options) {
-  const ts = await import("typescript");
   const baseDir = resolve(options.dir);
-  const layout = discoverDataLayout(ts, baseDir, options.config ? resolve(options.config) : void 0);
+  const project = await loadGeneratorProject(baseDir);
+  try {
+    return generateDrizzleSchemaInputFileWithProject(options, project);
+  } finally {
+    await project.close();
+  }
+}
+async function generateDrizzleSchemaInputFileWithProject(options, project) {
+  const baseDir = resolve(options.dir);
+  const layout = discoverDataLayout(project, baseDir, options.config ? resolve(options.config) : void 0);
   const tableNames = dataMembershipFromLayout(layout).allTables;
   const relationsPath = layout.metadataPaths.find(path => basename(path) === "relations.ts" && dirname(path) === resolve(dirname(baseDir), "database")) ?? layout.metadataPaths.find(path => basename(path) === "relations.ts");
   const relationEntries = [];
   if (relationsPath) {
-    const source = ts.createSourceFile(relationsPath, readFileSync(relationsPath, "utf8"), ts.ScriptTarget.Latest, true);
+    const source = project.sourceFile(relationsPath);
     const included = new Set(tableNames);
     const visit = node => {
       if (!ts.isCallExpression(node) || node.expression.getText(source) !== "defineRelations") {
-        ts.forEachChild(node, visit);
+        node.forEachChild(visit);
         return;
       }
       const factory = node.arguments[1];
@@ -587,6 +551,14 @@ ${relations.map(relation => `    ${relation},`).join("\n")}
   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) {
+  const project = await loadGeneratorProject(resolve(options.dir));
+  try {
+    return await generateWithProject(options, project);
+  } finally {
+    await project.close();
+  }
+}
+async function generateWithProject(options, project) {
   const {
     dir,
     after,
@@ -602,11 +574,41 @@ async function generate(options) {
     });
   }
   loadCache();
-  const ts = await import("typescript");
-  const layout = discoverDataLayout(ts, baseDir, config ? resolve(config) : void 0);
+  const layout = discoverDataLayout(project, baseDir, config ? resolve(config) : void 0);
   const metadataHash = hash(layout.metadataPaths.map(path => `${path}\0${readFileSync(path, "utf8")}`).join("\0"));
+  const databaseSchemaPath = resolve(dirname(baseDir), "database/schema.ts");
+  const needsSqliteZeroSchema = existsSync(databaseSchemaPath);
   const inputHash = hash(`${hashInputTree(layout.sourceRoots, generatedDir)}\0${metadataHash}`);
-  if (!force && generateCache.__generatorVersion === GENERATOR_CACHE_VERSION && generateCache.__inputHash === inputHash && existsSync(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(([cachedPath, cachedHash]) => {
+    if (!cachedPath.startsWith(generatedDir)) return true;
+    try {
+      return hash(readFileSync(cachedPath, "utf-8")) === cachedHash;
+    } catch {
+      return false;
+    }
+  }) && existsSync(resolve(generatedDir, "models.ts")) && (!needsSqliteZeroSchema || existsSync(resolve(generatedDir, "schema.ts")))) {
     let counts = {};
     try {
       counts = JSON.parse(generateCache.__counts || "{}");
@@ -635,6 +637,24 @@ async function generate(options) {
   // managed externally and should not be overwritten.
   ...(filesWithSchema.length > 0 ? [writeFileIfChanged(resolve(generatedDir, "types.ts"), generateTypesFile(schemaModules.map(module => module.name))), writeFileIfChanged(resolve(generatedDir, "tables.ts"), generateTablesFile(schemaModules))] : []), writeFileIfChanged(resolve(generatedDir, "README.md"), generateReadmeFile())];
   let filesChanged = writeResults.filter(Boolean).length;
+  if (needsSqliteZeroSchema) {
+    const membership = dataMembershipFromLayout(layout);
+    const drizzleSchema = await generateDrizzleSchemaInputFileWithProject({
+      dir: baseDir,
+      schemaImportPath: "../../database/schema",
+      config
+    }, project);
+    const sqliteSchema = renderDrizzleZeroSqliteSchemaModule({
+      importPath: "./drizzleSchema",
+      tableNames: membership.allTables
+    });
+    if (writeFileIfChanged(resolve(generatedDir, "drizzleSchema.ts"), drizzleSchema)) {
+      filesChanged++;
+    }
+    if (writeFileIfChanged(resolve(generatedDir, "schema.ts"), sqliteSchema)) {
+      filesChanged++;
+    }
+  }
   let queryCount = 0;
   let mutationCount = 0;
   const typeToValibot = paramType => {
@@ -645,23 +665,12 @@ async function generate(options) {
     }
   };
   const allQueries = [];
-  let queryResolver = null;
-  const getQueryResolver = () => {
-    if (!queryResolver) {
-      const allFiles = [...new Set(layout.namespaces.flatMap(namespace => namespace.sourcePaths))].map(path => ({
-        path,
-        content: readFileSync(path, "utf-8")
-      }));
-      queryResolver = createTypeResolver(ts, allFiles, baseDir);
-    }
-    return queryResolver;
-  };
   for (const namespace of layout.namespaces.filter(namespace2 => namespace2.queryPath !== null)) {
     const filePath = namespace.queryPath;
     try {
-      const content = readFileSync(filePath, "utf-8");
-      const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-      ts.forEachChild(sourceFile, node => {
+      const sourceFile = project.sourceFile(filePath);
+      const candidates = [];
+      sourceFile.forEachChild(node => {
         if (ts.isVariableStatement(node)) {
           const exportModifier = node.modifiers?.find(m => m.kind === ts.SyntaxKind.ExportKeyword);
           if (!exportModifier) return;
@@ -676,31 +685,33 @@ async function generate(options) {
               const param = params[0];
               paramType = param.type?.getText(sourceFile) || "unknown";
             }
-            let valibotCode = typeToValibot(paramType);
-            if (!valibotCode && params.length > 0 && params[0].type) {
-              const resolver = getQueryResolver();
-              const resolverSourceFile = resolver.program.getSourceFile(filePath);
-              if (resolverSourceFile) {
-                const resolvedType = resolveParamType(ts, resolver, resolverSourceFile, name, 0);
-                if (resolvedType) {
-                  valibotCode = resolver.typeToValibot(resolvedType);
-                }
-              }
-            }
-            if (valibotCode) {
-              allQueries.push({
-                name,
-                params: paramType,
-                valibotCode,
-                sourceFile: namespace.name,
-                importPath: namespaceImportPath(baseDir, filePath)
-              });
-            } else if (!silent && paramType !== "void") {
-              console.error(`\u2717 ${name}: could not resolve type "${paramType}"`);
-            }
+            candidates.push({
+              name,
+              paramType,
+              typeNode: params[0]?.type ?? null
+            });
           }
         }
       });
+      const resolver = createTypeResolver(project.projectForFile(filePath));
+      for (const candidate of candidates) {
+        let valibotCode = typeToValibot(candidate.paramType);
+        if (!valibotCode && candidate.typeNode) {
+          const resolvedType = await resolveParamType(resolver, sourceFile, candidate.name, 0);
+          if (resolvedType) valibotCode = await resolver.typeToValibot(resolvedType);
+        }
+        if (valibotCode) {
+          allQueries.push({
+            name: candidate.name,
+            params: candidate.paramType,
+            valibotCode,
+            sourceFile: namespace.name,
+            importPath: namespaceImportPath(baseDir, filePath)
+          });
+        } else if (!silent && candidate.paramType !== "void") {
+          console.error(`\u2717 ${candidate.name}: could not resolve type "${candidate.paramType}"`);
+        }
+      }
     } catch (err) {
       if (!silent) console.error(`Error processing ${filePath}:`, err);
     }
@@ -729,20 +740,14 @@ async function generate(options) {
     if (aggregatesChanged) filesChanged++;
   }
   const allModelMutations = [];
-  const mutationFiles = [];
   const unresolvedModels = [];
   for (const namespace of modelNamespaces) {
     const filePath = namespace.modelPath;
     const fileBaseName = namespace.name;
     try {
       const content = readFileSync(filePath, "utf-8");
-      mutationFiles.push({
-        path: filePath,
-        content,
-        baseName: fileBaseName
-      });
-      const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-      const result = extractMutationsFromModel(ts, sourceFile, content, filePath, !!silent, typeToValibot);
+      const sourceFile = project.sourceFile(filePath);
+      const result = extractMutationsFromModel(sourceFile, content, filePath, !!silent, typeToValibot);
       if (result) {
         result.modelName = fileBaseName;
         allModelMutations.push(result);
@@ -759,36 +764,20 @@ async function generate(options) {
     }
   }
   if (unresolvedModels.length > 0) {
-    const collectTsFiles = dir2 => {
-      const results = [];
-      for (const entry of readdirSync(dir2, {
-        withFileTypes: true
-      })) {
-        const fullPath = 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: readFileSync(fullPath, "utf-8")
-          });
-        }
-      }
-      return results;
-    };
-    const allFiles = [...new Map(layout.sourceRoots.flatMap(collectTsFiles).map(file => [file.path, file])).values()];
-    const modelResolver = createTypeResolver(ts, allFiles, baseDir);
     for (const {
       baseName,
       filePath
     } of unresolvedModels) {
-      const resolverSourceFile = modelResolver.program.getSourceFile(filePath);
-      if (!resolverSourceFile) continue;
-      const resolvedTypes = resolveMutationParamTypes(ts, modelResolver, resolverSourceFile);
+      const sourceFile = project.sourceFile(filePath);
+      const modelResolver = createTypeResolver(project.projectForFile(filePath));
+      const resolvedTypes = await resolveMutationParamTypes(modelResolver, sourceFile);
       if (resolvedTypes.size === 0) continue;
+      const resolvedValibot = /* @__PURE__ */new Map();
+      for (const [name, type] of resolvedTypes) {
+        resolvedValibot.set(name, await modelResolver.typeToValibot(type));
+      }
       const content = readFileSync(filePath, "utf-8");
-      const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-      const result = extractMutationsFromModel(ts, sourceFile, content, filePath, !!silent, typeToValibot, resolvedTypes, modelResolver.typeToValibot);
+      const result = extractMutationsFromModel(sourceFile, content, filePath, !!silent, typeToValibot, resolvedValibot);
       if (result) {
         result.modelName = baseName;
         const idx = allModelMutations.findIndex(m => m.modelName === baseName);
@@ -866,8 +855,13 @@ ${event} ${path}`);
     }, debounce);
   };
   const databaseDir = resolve(dirname(baseDir), "database");
-  const ts = await import("typescript");
-  const layout = discoverDataLayout(ts, baseDir, options.config ? resolve(options.config) : void 0);
+  const project = await loadGeneratorProject(baseDir);
+  let layout;
+  try {
+    layout = discoverDataLayout(project, baseDir, options.config ? resolve(options.config) : void 0);
+  } finally {
+    await project.close();
+  }
   const watcher = chokidar.watch([... /* @__PURE__ */new Set([...layout.sourceRoots, ...(existsSync(databaseDir) ? [databaseDir] : [])])], {
     persistent: true,
     ignoreInitial: true,