@tailorkit/app 0.1.0-beta.23 → 0.1.0-beta.24

package/dist/builder.js

@@ -1,12 +1,12 @@
 import {
   loadTailorKitConfig
-} from "./chunk-DEU6RITM.js";
-import "./chunk-GVB2PAK7.js";
+} from "./chunk-L5ECQGR7.js";
+import "./chunk-DA2TE2FW.js";
 
 // src/builder/index.ts
-import path7 from "path";
+import path9 from "path";
 import { createRequire as createRequire2 } from "module";
-import { readFile as readFile4, realpath, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile4, realpath, writeFile as writeFile3 } from "fs/promises";
 
 // ../asset-delivery/dist/logo-validation.mjs
 var maxLogoBytes = 262144;
@@ -136,7 +136,7 @@ var inspectClient = `
 import { readFile } from "node:fs/promises";
 const source = await readFile(process.argv[1], "utf8");
 const { default: client } = await import("data:text/javascript;base64," + Buffer.from(source).toString("base64"));
-if (!client?.slots || typeof client.slots !== "object") throw new Error("Client must default-export defineClient(...)");
+if (!client?.slots || typeof client.slots !== "object") throw new Error("Invalid generated app client: missing slots");
 const instanceResolvers = [];
 const views = Object.entries(client.slots).flatMap(([slot, definitions]) =>
   Object.entries(definitions).flatMap(([path, view]) => {
@@ -169,15 +169,15 @@ async function readClientManifest(filename) {
     return { views, instanceResolvers: manifest.instanceResolvers };
   } catch (error) {
     throw new Error(
-      "Unable to read app views during the build. Keep browser-only side effects inside components or effects, and default-export defineClient(...).",
+      "Unable to read app views during the build. Keep browser-only side effects inside components or effects. Check the default exports of your roots, layouts and .view.tsx files.",
       { cause: error }
     );
   }
 }
 
 // src/builder/server.ts
-import { mkdir, mkdtemp as mkdtemp2, writeFile, cp, rm as rm2 } from "fs/promises";
-import path5 from "path";
+import { mkdir as mkdir2, mkdtemp as mkdtemp3, writeFile as writeFile2, cp, rm as rm3 } from "fs/promises";
+import path7 from "path";
 import { build } from "vite";
 
 // src/builder/migrations.ts
@@ -219,24 +219,35 @@ async function readAppMigrations(directory, optional = false) {
 // src/server/bundle.ts
 var runtimeManifest = {
   apiVersion: 1,
-  requires: ["database", "actions"]
+  requires: ["database", "actions", "database-relations"]
 };
 
 // src/builder/schema-check.ts
 import { execFile as execFile2 } from "child_process";
 import { access as access2, mkdtemp, readFile as readFile2, readdir as readdir2, rm } from "fs/promises";
 import { tmpdir } from "os";
-import path3 from "path";
+import path4 from "path";
 import { promisify as promisify2 } from "util";
 
 // src/builder/drizzle.ts
 import { access } from "fs/promises";
 import { createRequire } from "module";
+import path3 from "path";
+
+// src/builder/database-paths.ts
 import path2 from "path";
+function appDatabasePaths(root, migrations) {
+  return {
+    schema: path2.join(root, "src/db/schema.ts"),
+    migrations: path2.resolve(root, migrations ?? "./src/db/migrations")
+  };
+}
+
+// src/builder/drizzle.ts
 async function drizzleGenerateArguments(root, output, name) {
-  const require2 = createRequire(path2.join(root, "package.json"));
+  const require2 = createRequire(path3.join(root, "package.json"));
   for (const directory of require2.resolve.paths("drizzle-kit") ?? []) {
-    const cli = path2.join(directory, "drizzle-kit/bin.cjs");
+    const cli = path3.join(directory, "drizzle-kit/bin.cjs");
     if (await access(cli).then(() => true).catch(() => false)) {
       return [
         "--preserve-symlinks-main",
@@ -245,7 +256,7 @@ async function drizzleGenerateArguments(root, output, name) {
         "--dialect",
         "sqlite",
         "--schema",
-        path2.join(root, "src/schema.ts"),
+        appDatabasePaths(root).schema,
         "--out",
         output,
         ...name === void 0 ? [] : ["--name", name]
@@ -266,7 +277,7 @@ async function snapshot(directory) {
   });
   const latest = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().at(-1);
   if (!latest) return;
-  const filename = path3.join(directory, latest, "snapshot.json");
+  const filename = path4.join(directory, latest, "snapshot.json");
   const value = JSON.parse(await readFile2(filename, "utf8"));
   if (value.version !== "7" || value.dialect !== "sqlite" || !Array.isArray(value.ddl)) {
     throw new Error(
@@ -283,14 +294,14 @@ function canonical(value) {
   return JSON.stringify(value);
 }
 async function checkAppSchema(root, migrationsDirectory) {
-  const schema = path3.join(root, "src/schema.ts");
+  const schema = appDatabasePaths(root).schema;
   try {
     await access2(schema);
   } catch (error) {
     if (error.code === "ENOENT") return;
     throw error;
   }
-  const temporary = await mkdtemp(path3.join(tmpdir(), "tailorkit-schema-check-"));
+  const temporary = await mkdtemp(path4.join(tmpdir(), "tailorkit-schema-check-"));
   try {
     const { stdout } = await run(
       process.execPath,
@@ -303,14 +314,14 @@ async function checkAppSchema(root, migrationsDirectory) {
       }
     ).catch((error) => {
       throw new Error(
-        "Could not check the app database schema with Drizzle Kit. Check src/schema.ts and your drizzle-kit/drizzle-orm dependencies.",
+        `Could not check the app database schema with Drizzle Kit. Check ${path4.relative(root, schema)} and your drizzle-kit/drizzle-orm dependencies.`,
         { cause: error }
       );
     });
     const current = await snapshot(temporary);
     if (!current && !stdout.includes("No schema changes")) {
       throw new Error(
-        "Drizzle Kit did not produce a schema snapshot. Check src/schema.ts and run tailorkit db generate."
+        `Drizzle Kit did not produce a schema snapshot. Check ${path4.relative(root, schema)} and run tailorkit db generate.`
       );
     }
     const saved = await snapshot(migrationsDirectory);
@@ -318,7 +329,7 @@ async function checkAppSchema(root, migrationsDirectory) {
     const actual = (saved?.ddl ?? []).map(canonical).sort();
     if (canonical(expected) !== canonical(actual)) {
       throw new Error(
-        `App database migrations are missing or out of sync with src/schema.ts. Run tailorkit db generate, commit the generated files in ${path3.relative(root, migrationsDirectory)}, then build again.`
+        `App database migrations are missing or out of sync with ${path4.relative(root, schema)}. Run tailorkit db generate, commit the generated files in ${path4.relative(root, migrationsDirectory)}, then build again.`
       );
     }
   } finally {
@@ -329,14 +340,432 @@ async function checkAppSchema(root, migrationsDirectory) {
 // src/builder/instances.ts
 import { createHash as createHash2 } from "crypto";
 import { readFile as readFile3 } from "fs/promises";
-import path4 from "path";
-import { parseSync, transformWithOxc } from "vite";
-var suffix = "?tailorkit-instances";
+import path6 from "path";
+import { parseSync as parseSync2, transformWithOxc } from "vite";
+
+// src/builder/file-routes.ts
+import { readdir as readdir3, mkdir, mkdtemp as mkdtemp2, writeFile, rm as rm2 } from "fs/promises";
+import { existsSync, watch } from "fs";
+import path5 from "path";
+import { parseSync } from "vite";
+
+// src/builder/define-view.ts
 var clientImports = /* @__PURE__ */ new Set([
   "tailorkit/client",
+  "tailorkit/app",
   "tailorkit/app/client",
-  "@tailorkit/app/client"
+  "@tailorkit/app/client",
+  "@tailorkit/app"
 ]);
+function createScope(parent, functionScope = false) {
+  return { parent, functionScope, bindings: /* @__PURE__ */ new Map() };
+}
+function bindingNames(node) {
+  if (!node) {
+    return [];
+  }
+  switch (node.type) {
+    case "Identifier": {
+      return [node.name];
+    }
+    case "RestElement": {
+      return bindingNames(node.argument);
+    }
+    case "AssignmentPattern": {
+      return bindingNames(node.left);
+    }
+    case "ArrayPattern": {
+      return node.elements.flatMap(bindingNames);
+    }
+    case "ObjectPattern": {
+      return node.properties.flatMap(
+        (property2) => bindingNames(property2.type === "Property" ? property2.value : property2.argument)
+      );
+    }
+    case "TSParameterProperty": {
+      return bindingNames(node.parameter);
+    }
+    default: {
+      return [];
+    }
+  }
+}
+function bind(node, scope) {
+  for (const name of bindingNames(node)) {
+    scope.bindings.set(name, "local");
+  }
+}
+function classScope(node, parent) {
+  if (node.type === "ClassDeclaration") {
+    bind(node.id, parent);
+  }
+  const scope = createScope(parent);
+  bind(node.id, scope);
+  return scope;
+}
+function resolve(scope, name) {
+  for (let current = scope; current; current = current.parent) {
+    if (current.bindings.has(name)) {
+      return current.bindings.get(name);
+    }
+  }
+}
+function childNodes(node) {
+  return Object.values(node).flatMap((value) => {
+    const children2 = Array.isArray(value) ? value : [value];
+    return children2.filter(
+      (child) => !!child && typeof child === "object" && "type" in child
+    );
+  });
+}
+function bindImports(node, scope) {
+  const sdk = node.importKind !== "type" && clientImports.has(String(node.source.value));
+  for (const specifier of node.specifiers) {
+    let binding = "local";
+    if (sdk && specifier.type === "ImportNamespaceSpecifier") {
+      binding = "namespace";
+    } else if (sdk && specifier.type === "ImportSpecifier" && specifier.importKind !== "type" && specifier.imported.type === "Identifier" && specifier.imported.name === "defineView") {
+      binding = "view";
+    }
+    scope.bindings.set(specifier.local.name, binding);
+  }
+}
+function callScopes(program) {
+  const scopes = /* @__PURE__ */ new WeakMap();
+  function visitFunction(node, scope) {
+    if (node.type === "FunctionDeclaration") {
+      bind(node.id, scope);
+    }
+    const parameters = createScope(scope, true);
+    if (node.type !== "ArrowFunctionExpression") {
+      bind(node.id, parameters);
+    }
+    for (const parameter of node.params) {
+      bind(parameter, parameters);
+    }
+    for (const parameter of node.params) {
+      visit(parameter, parameters);
+    }
+    if (node.body) {
+      visit(node.body, createScope(parameters, true));
+    }
+  }
+  function bindVariables(node, scope) {
+    let target = scope;
+    if (node.kind === "var") {
+      while (!target.functionScope && target.parent) {
+        target = target.parent;
+      }
+    }
+    for (const declaration of node.declarations) {
+      bind(declaration.id, target);
+    }
+  }
+  function visit(node, scope) {
+    scopes.set(node, scope);
+    switch (node.type) {
+      case "ImportDeclaration": {
+        bindImports(node, scope);
+        return;
+      }
+      case "VariableDeclaration": {
+        bindVariables(node, scope);
+        break;
+      }
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression": {
+        visitFunction(node, scope);
+        return;
+      }
+      case "ClassDeclaration":
+      case "ClassExpression": {
+        scope = classScope(node, scope);
+        break;
+      }
+      case "CatchClause": {
+        scope = createScope(scope);
+        bind(node.param, scope);
+        break;
+      }
+      case "SwitchStatement": {
+        visit(node.discriminant, scope);
+        scope = createScope(scope);
+        for (const branch of node.cases) {
+          visit(branch, scope);
+        }
+        return;
+      }
+      case "BlockStatement":
+      case "ForStatement":
+      case "ForInStatement":
+      case "ForOfStatement": {
+        scope = createScope(scope);
+        break;
+      }
+      case "StaticBlock":
+      case "TSModuleBlock": {
+        scope = createScope(scope, true);
+        break;
+      }
+      case "TSEnumDeclaration":
+      case "TSModuleDeclaration": {
+        bind(node.id, scope);
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+    for (const child of childNodes(node)) {
+      visit(child, scope);
+    }
+  }
+  visit(program, createScope(void 0, true));
+  return scopes;
+}
+function createDefineViewMatcher(program) {
+  const scopes = callScopes(program);
+  return (node) => {
+    if (node.type !== "CallExpression") {
+      return false;
+    }
+    const { callee } = node;
+    const scope = scopes.get(node);
+    if (callee.type === "Identifier") {
+      return resolve(scope, callee.name) === "view";
+    }
+    if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier" || resolve(scope, callee.object.name) !== "namespace") {
+      return false;
+    }
+    return callee.computed ? callee.property.type === "Literal" && callee.property.value === "defineView" : callee.property.type === "Identifier" && callee.property.name === "defineView";
+  };
+}
+
+// src/builder/file-routes.ts
+var clientRuntimeImport = "tailorkit:file-client-runtime";
+function fileViewLocation(filename, root) {
+  const relative = path5.relative(path5.join(root, "src/slots"), filename).split(path5.sep);
+  if (relative.length < 2 || relative[0] === ".." || !filename.endsWith(".view.tsx")) {
+    return;
+  }
+  const [slot, ...routeSegments] = relative;
+  if (!slot) {
+    return;
+  }
+  const basename = routeSegments.join("/").slice(0, -".view.tsx".length);
+  return { slot, path: routePath(basename, filename) };
+}
+function routePath(name, filename) {
+  const segments = name.split(/[./]/u);
+  if (segments.some((segment) => !segment || segment === "..")) {
+    throw new Error(`${filename} has an empty route segment. Use route.nested-route.view.tsx.`);
+  }
+  return `/${segments.join("/")}`;
+}
+function inferFileView(source, filename, root) {
+  const location = fileViewLocation(filename, root);
+  if (!location) {
+    return source;
+  }
+  const { slot, path: viewPath } = location;
+  const parsed = parseSync(filename, source);
+  if (parsed.errors.length) {
+    throw new Error(`${filename}: ${parsed.errors[0]?.message}`);
+  }
+  const isDefineViewCall = createDefineViewMatcher(parsed.program);
+  const edits = [];
+  function visit(node) {
+    if (isDefineViewCall(node)) {
+      const options = node.arguments[0];
+      if (options?.type !== "ObjectExpression") {
+        throw new Error(
+          `${filename}: file views require defineView with an inline options object.`
+        );
+      }
+      const properties = new Set(
+        options.properties.flatMap((property2) => {
+          if (property2.type !== "Property" || property2.computed) {
+            return [];
+          }
+          if (property2.key.type === "Identifier") {
+            return [property2.key.name];
+          }
+          if (property2.key.type === "Literal") {
+            return [String(property2.key.value)];
+          }
+          return [];
+        })
+      );
+      const defaults = [
+        !properties.has("slot") ? `slot: ${JSON.stringify(slot)},` : "",
+        !properties.has("view") ? `view: ${JSON.stringify(viewPath)},` : ""
+      ].join("");
+      if (defaults) {
+        edits.push({ position: options.start + 1, text: defaults });
+      }
+    }
+    for (const value of Object.values(node)) {
+      const children2 = Array.isArray(value) ? value : [value];
+      for (const child of children2) {
+        if (child && typeof child === "object" && "type" in child) {
+          visit(child);
+        }
+      }
+    }
+  }
+  visit(parsed.program);
+  for (const edit of edits.toSorted((a, b) => b.position - a.position)) {
+    source = source.slice(0, edit.position) + edit.text + source.slice(edit.position);
+  }
+  return source;
+}
+async function discoverFileRoutes(root) {
+  const views = [];
+  const roots = [];
+  const layouts = [];
+  const slotsDir = path5.join(root, "src/slots");
+  async function scan(directory, slot, prefix = "") {
+    const entries = await readdir3(directory, { withFileTypes: true }).catch(
+      (error) => {
+        if (error.code === "ENOENT") {
+          return [];
+        }
+        throw error;
+      }
+    );
+    for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+      const filename = path5.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        await scan(filename, slot ?? entry.name, slot ? `${prefix}${entry.name}/` : "");
+      } else if (entry.isFile() && slot) {
+        if (entry.name.endsWith(".view.tsx")) {
+          fileViewLocation(filename, root);
+          views.push({ filename, slot });
+        } else if (entry.name === "root.tsx" && !prefix) {
+          roots.push({ filename, slot });
+        } else if (entry.name === "layout.tsx" || entry.name.endsWith(".layout.tsx")) {
+          const name = entry.name === "layout.tsx" ? prefix.replace(/\/$/u, "") : prefix + entry.name.slice(0, -".layout.tsx".length);
+          layouts.push({ filename, slot, path: name ? routePath(name, filename) : "/" });
+        }
+      }
+    }
+  }
+  await scan(slotsDir);
+  const rootFile = path5.join(root, "src/root.tsx");
+  return {
+    root: existsSync(rootFile) ? { filename: rootFile } : void 0,
+    roots,
+    layouts,
+    views
+  };
+}
+async function getClientSourceFiles(root) {
+  const discovered = await discoverFileRoutes(root);
+  const bindings = path5.join(root, "src/tailorkit.gen.ts");
+  return [
+    ...discovered.root ? [discovered.root.filename] : [],
+    ...discovered.roots.map((module) => module.filename),
+    ...discovered.layouts.map((module) => module.filename),
+    ...discovered.views.map((module) => module.filename),
+    ...existsSync(bindings) ? [bindings] : []
+  ];
+}
+async function fileClientSource(root) {
+  const discovered = await discoverFileRoutes(root);
+  const imports = [`import { createFileClient } from ${JSON.stringify(clientRuntimeImport)};`];
+  let index = 0;
+  function module(entry) {
+    const binding = `module${index++}`;
+    imports.push(`import ${binding} from ${JSON.stringify(entry.filename)};`);
+    return `{ filename: ${JSON.stringify(path5.relative(root, entry.filename))}, definition: ${binding}`;
+  }
+  const rootModule = discovered.root ? `${module(discovered.root)} }` : "undefined";
+  const roots = discovered.roots.map(
+    (entry) => `${module(entry)}, slot: ${JSON.stringify(entry.slot)} }`
+  );
+  const layouts = discovered.layouts.map(
+    (entry) => `${module(entry)}, slot: ${JSON.stringify(entry.slot)}, path: ${JSON.stringify(entry.path)} }`
+  );
+  const views = discovered.views.map(
+    (entry) => `${module(entry)}, slot: ${JSON.stringify(entry.slot)} }`
+  );
+  return `${imports.join("\n")}
+export default createFileClient({ root: ${rootModule}, roots: [${roots.join(",")}], layouts: [${layouts.join(",")}], views: [${views.join(",")}] });`;
+}
+async function createFileRouteEntry(root, output, watching) {
+  let source = await fileClientSource(root);
+  const temporaryRoot = path5.join(output, "tmp");
+  await mkdir(temporaryRoot, { recursive: true });
+  const directory = await mkdtemp2(path5.join(temporaryRoot, "client-"));
+  const entry = path5.join(directory, "entry.ts");
+  await writeFile(entry, source);
+  let pending = Promise.resolve();
+  let closed = false;
+  let timer;
+  async function refresh() {
+    if (closed) {
+      return;
+    }
+    let next;
+    try {
+      next = await fileClientSource(root);
+    } catch (error) {
+      next = `throw new Error(${JSON.stringify(error instanceof Error ? error.message : String(error))});`;
+    }
+    if (next === source) {
+      return;
+    }
+    source = next;
+    await writeFile(entry, next);
+  }
+  const watcher = watching ? watch(path5.join(root, "src"), { recursive: true }, () => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      pending = pending.then(refresh);
+    }, 25);
+  }) : void 0;
+  return {
+    entry,
+    async close() {
+      closed = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      watcher?.close();
+      try {
+        await pending;
+      } finally {
+        await rm2(directory, { recursive: true, force: true });
+      }
+    }
+  };
+}
+function fileRoutesPlugin(root) {
+  return {
+    name: "tailorkit-file-routes",
+    enforce: "pre",
+    async resolveId(id) {
+      if (id !== clientRuntimeImport) {
+        return;
+      }
+      const importer = path5.join(root, "src/root.tsx");
+      return await this.resolve("tailorkit/client", importer, { skipSelf: true }) ?? this.resolve("@tailorkit/app/client", importer, { skipSelf: true });
+    },
+    transform(source, filename) {
+      if (!filename.endsWith(".view.tsx")) {
+        return;
+      }
+      const code = inferFileView(source, filename, root);
+      return code === source ? void 0 : { code, map: null };
+    }
+  };
+}
+
+// src/builder/instances.ts
+var suffix = "?tailorkit-instances";
 var browserGlobals = /* @__PURE__ */ new Set([
   "window",
   "document",
@@ -487,7 +916,7 @@ function property(node, name) {
   );
 }
 function parse(filename, source) {
-  const result = parseSync(filename, source);
+  const result = parseSync2(filename, source);
   if (result.errors.length)
     throw new Error(`Unable to parse ${filename}: ${result.errors[0]?.message}`);
   return result.program;
@@ -552,25 +981,19 @@ function renderImports(imports, needed, source, sideEffects) {
   }).join("\n");
 }
 async function extractInstances(filename, source, root, includedNames) {
+  source = inferFileView(source, filename, root);
   const transformed = await transformWithOxc(source, filename, {
     jsx: { importSource: "preact" },
     sourcemap: false
   });
   source = transformed.code;
   const program = parse(filename.replace(/\.[^.]+$/u, ".js"), source);
-  const aliases = /* @__PURE__ */ new Set();
-  for (const statement of program.body) {
-    if (statement.type !== "ImportDeclaration" || !clientImports.has(String(statement.source.value)))
-      continue;
-    for (const s of statement.specifiers) {
-      if (s.type === "ImportSpecifier" && s.imported.type === "Identifier" && s.imported.name === "defineView")
-        aliases.add(s.local.name);
-    }
-  }
+  const isDefineViewCall = createDefineViewMatcher(program);
   let resolvers = [];
   walk(program, (node, ancestors) => {
-    if (node.type !== "CallExpression" || node.callee.type !== "Identifier" || !aliases.has(node.callee.name))
+    if (!isDefineViewCall(node)) {
       return;
+    }
     const options = node.arguments[0];
     if (options?.type !== "ObjectExpression") return;
     const instances = property(options, "instances");
@@ -590,12 +1013,12 @@ async function extractInstances(filename, source, root, includedNames) {
     const config = instances.value;
     if (config.properties.some((p) => p.type !== "Property" || p.computed || p.kind !== "init"))
       fail("Instance options cannot contain spreads, getters or computed properties.");
-    const resolve = property(config, "resolve");
+    const resolve2 = property(config, "resolve");
     const schema = property(config, "dataSchema");
-    if (!resolve || !schema || resolve.method || !["ArrowFunctionExpression", "FunctionExpression"].includes(resolve.value.type))
+    if (!resolve2 || !schema || resolve2.method || !["ArrowFunctionExpression", "FunctionExpression"].includes(resolve2.value.type))
       fail("instances requires dataSchema and an inline resolve function.");
     const name = `i${createHash2("sha256").update(
-      `${path4.relative(root, filename).split(path4.sep).join("/")}\0${viewName}\0${view.value}`
+      `${path6.relative(root, filename).split(path6.sep).join("/")}\0${viewName}\0${view.value}`
     ).digest("hex").slice(0, 24)}`;
     if (resolvers.some((r) => r.name === name))
       fail("Instance resolvers must have distinct module-level variable names.");
@@ -604,7 +1027,7 @@ async function extractInstances(filename, source, root, includedNames) {
       view: view.value,
       call: node,
       instances,
-      resolve,
+      resolve: resolve2,
       schema
     });
   });
@@ -720,34 +1143,34 @@ function instanceServerBindings(modules, registrations) {
 }
 
 // src/builder/server.ts
-async function buildServer(loaded, watch = false, buildOutDir, instances = [], registrations = []) {
+async function buildServer(loaded, watch2 = false, buildOutDir, instances = [], registrations = []) {
   const config = loaded.config.server;
   if (!config) {
     return;
   }
-  const output = buildOutDir ?? path5.resolve(loaded.root, loaded.config.build?.outDir ?? ".tailorkit");
-  const directory = path5.join(output, "server");
-  const migrationsDirectory = path5.resolve(loaded.root, config.migrations ?? "./migrations");
-  const migrationsOutput = path5.join(output, "migrations");
-  const temporaryRoot = path5.join(output, "tmp");
+  const output = buildOutDir ?? path7.resolve(loaded.root, loaded.config.build?.outDir ?? ".tailorkit");
+  const directory = path7.join(output, "server");
+  const migrationsDirectory = appDatabasePaths(loaded.root, config.migrations).migrations;
+  const migrationsOutput = path7.join(output, "migrations");
+  const temporaryRoot = path7.join(output, "tmp");
   validateServerBuildOutput(loaded, output);
-  await rm2(directory, { recursive: true, force: true });
-  await mkdir(directory, { recursive: true });
-  await mkdir(temporaryRoot, { recursive: true });
-  const temporary = await mkdtemp2(path5.join(temporaryRoot, "server-"));
-  const entry = path5.join(temporary, "entry.mjs");
+  await rm3(directory, { recursive: true, force: true });
+  await mkdir2(directory, { recursive: true });
+  await mkdir2(temporaryRoot, { recursive: true });
+  const temporary = await mkdtemp3(path7.join(temporaryRoot, "server-"));
+  const entry = path7.join(temporary, "entry.mjs");
   let watching = false;
   let ready;
-  const initialBuild = watch ? new Promise((resolve) => {
-    ready = resolve;
+  const initialBuild = watch2 ? new Promise((resolve2) => {
+    ready = resolve2;
   }) : void 0;
   try {
-    await writeFile(
+    await writeFile2(
       entry,
-      `${instances.length ? `import app from ${JSON.stringify(path5.resolve(loaded.root, config.entry ?? "src/server.ts"))};
+      `${instances.length ? `import app from ${JSON.stringify(path7.resolve(loaded.root, config.entry ?? "src/server.ts"))};
 import { withInstanceResolvers } from "tailorkit/server";
 ${instanceServerImports(instances)}
-export default withInstanceResolvers(app, ${instanceServerBindings(instances, registrations)});` : `export { default } from ${JSON.stringify(path5.resolve(loaded.root, config.entry ?? "src/server.ts"))};`}
+export default withInstanceResolvers(app, ${instanceServerBindings(instances, registrations)});` : `export { default } from ${JSON.stringify(path7.resolve(loaded.root, config.entry ?? "src/server.ts"))};`}
 export { default as migrations } from "tailorkit:migrations";
 export const runtimeManifest = ${JSON.stringify(runtimeManifest)};
 `
@@ -759,7 +1182,7 @@ export const runtimeManifest = ${JSON.stringify(runtimeManifest)};
         instanceServerPlugin(loaded.root, instances),
         {
           name: "tailorkit-app-migrations",
-          closeWatcher: () => rm2(temporary, { recursive: true, force: true }),
+          closeWatcher: () => rm3(temporary, { recursive: true, force: true }),
           resolveId(id) {
             if (id === "tailorkit:migrations") {
               return "\0tailorkit:migrations";
@@ -774,12 +1197,12 @@ export const runtimeManifest = ${JSON.stringify(runtimeManifest)};
               config.migrations === void 0
             );
             await checkAppSchema(loaded.root, migrationsDirectory);
-            this.addWatchFile(path5.join(loaded.root, "src/schema.ts"));
+            this.addWatchFile(appDatabasePaths(loaded.root).schema);
             for (const file of files) {
               this.addWatchFile(file);
             }
-            await rm2(migrationsOutput, { recursive: true, force: true });
-            await mkdir(migrationsOutput, { recursive: true });
+            await rm3(migrationsOutput, { recursive: true, force: true });
+            await mkdir2(migrationsOutput, { recursive: true });
             await cp(migrationsDirectory, migrationsOutput, { recursive: true }).catch(
               (error) => {
                 if (config.migrations === void 0 && error.code === "ENOENT") {
@@ -797,7 +1220,7 @@ export const runtimeManifest = ${JSON.stringify(runtimeManifest)};
         outDir: directory,
         emptyOutDir: false,
         target: "es2022",
-        watch: watch ? {} : null,
+        watch: watch2 ? {} : null,
         minify: "oxc",
         rollupOptions: {
           external: [],
@@ -811,8 +1234,8 @@ export const runtimeManifest = ${JSON.stringify(runtimeManifest)};
       },
       ssr: { noExternal: true }
     });
-    watching = watch;
-    if (watch && "on" in result && initialBuild) {
+    watching = watch2;
+    if (watch2 && "on" in result && initialBuild) {
       try {
         await Promise.race([
           initialBuild,
@@ -830,25 +1253,25 @@ export const runtimeManifest = ${JSON.stringify(runtimeManifest)};
     }
     return result;
   } finally {
-    if (!watching) await rm2(temporary, { recursive: true, force: true });
+    if (!watching) await rm3(temporary, { recursive: true, force: true });
   }
 }
 function validateServerBuildOutput(loaded, output) {
   if (!loaded.config.server) return;
-  const migrationsDirectory = path5.resolve(
+  const migrationsDirectory = appDatabasePaths(
     loaded.root,
-    loaded.config.server.migrations ?? "./migrations"
-  );
+    loaded.config.server.migrations
+  ).migrations;
   for (const name of ["server", "client", "migrations", "tmp"]) {
-    if (overlaps(migrationsDirectory, path5.join(output, name))) {
+    if (overlaps(migrationsDirectory, path7.join(output, name))) {
       throw new Error("App build output must not overlap migration source");
     }
   }
 }
 function overlaps(source, destination) {
   const contains = (parent, child) => {
-    const relative = path5.relative(parent, child);
-    return relative === "" || !path5.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path5.sep}`);
+    const relative = path7.relative(parent, child);
+    return relative === "" || !path7.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path7.sep}`);
   };
   return contains(source, destination) || contains(destination, source);
 }
@@ -856,7 +1279,7 @@ function overlaps(source, destination) {
 // src/builder/generate-migrations.ts
 import { spawn } from "child_process";
 import { access as access3 } from "fs/promises";
-import path6 from "path";
+import path8 from "path";
 async function generateAppMigrations(options = {}) {
   const loaded = await loadTailorKitConfig(options.configPath, options.cwd);
   if (!loaded.config.server) {
@@ -864,19 +1287,20 @@ async function generateAppMigrations(options = {}) {
       "Enable server: {} in tailorkit.config.ts before generating database migrations."
     );
   }
-  await access3(path6.join(loaded.root, "src/schema.ts")).catch((error) => {
+  const paths = appDatabasePaths(loaded.root, loaded.config.server.migrations);
+  await access3(paths.schema).catch((error) => {
     throw new Error(
-      "Define the app database schema in src/schema.ts before generating migrations.",
+      `Define the app database schema in ${path8.relative(loaded.root, paths.schema)} before generating migrations.`,
       { cause: error }
     );
   });
-  const directory = path6.resolve(loaded.root, loaded.config.server.migrations ?? "./migrations");
+  const directory = paths.migrations;
   const args = await drizzleGenerateArguments(loaded.root, directory, options.name);
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const child = spawn(process.execPath, args, { cwd: loaded.root, stdio: "inherit" });
     child.once("error", reject);
     child.once("close", (code, signal) => {
-      if (code === 0) resolve();
+      if (code === 0) resolve2();
       else reject(new Error(`Drizzle migration generation failed (${signal ?? code}).`));
     });
   });
@@ -890,19 +1314,20 @@ var preactPackageJsonModuleId = "\0tailorkit-preact-package-json";
 var buildApp = async (options = {}) => {
   const loaded = await loadTailorKitConfig(options.configPath, options.cwd);
   loaded.root = await realpath(loaded.root);
-  const entry = path7.resolve(loaded.root, loaded.config.client?.entry ?? "src/client.ts");
-  const serverEntry = path7.resolve(loaded.root, loaded.config.server?.entry ?? "src/server.ts");
+  const serverEntry = path9.resolve(loaded.root, loaded.config.server?.entry ?? "src/server.ts");
   const outDir = options.outDir ?? loaded.config.build?.outDir ?? ".tailorkit";
   const preactVersion = getInstalledPreactVersion(loaded.root);
   assertSupportedPreactVersion(preactVersion);
-  const resolvedOutDir = path7.resolve(loaded.root, outDir);
+  const resolvedOutDir = path9.resolve(loaded.root, outDir);
   validateServerBuildOutput(loaded, resolvedOutDir);
-  const clientOutDir = path7.join(resolvedOutDir, "client");
+  const clientOutDir = path9.join(resolvedOutDir, "client");
+  const fileEntry = await createFileRouteEntry(loaded.root, resolvedOutDir, Boolean(options.watch));
+  const entry = fileEntry.entry;
   const instanceModules = /* @__PURE__ */ new Map();
   let serverWatcher;
   const writeBuildExtras = async () => {
     const { views, instanceResolvers } = await readClientManifest(
-      path7.join(clientOutDir, "client.js")
+      path9.join(clientOutDir, "client.js")
     );
     const resolverNames = new Set(instanceResolvers.map((registration) => registration.resolver));
     const activeModules = [...instanceModules.values()].map((module) => ({
@@ -928,21 +1353,21 @@ var buildApp = async (options = {}) => {
       if (!configuredPath) {
         continue;
       }
-      const extension = path7.extname(configuredPath).toLowerCase().slice(1);
+      const extension = path9.extname(configuredPath).toLowerCase().slice(1);
       const contentType = { png: "image/png", svg: "image/svg+xml", webp: "image/webp" }[extension];
       if (!contentType) {
         throw new Error(`The ${variant} logo must be an SVG, PNG, or WebP file.`);
       }
-      const content = await readFile4(path7.resolve(loaded.root, configuredPath));
+      const content = await readFile4(path9.resolve(loaded.root, configuredPath));
       validateLogoAsset(content, contentType);
       const filename = `logo-${variant}.${extension}`;
-      await writeFile2(path7.join(clientOutDir, filename), content);
+      await writeFile3(path9.join(clientOutDir, filename), content);
       logoManifest[variant] = `client/${filename}`;
     }
-    await writeFile2(path7.join(clientOutDir, "views.json"), `${JSON.stringify(views)}
+    await writeFile3(path9.join(clientOutDir, "views.json"), `${JSON.stringify(views)}
 `);
-    await writeFile2(
-      path7.join(resolvedOutDir, "tailorkit-upload.json"),
+    await writeFile3(
+      path9.join(resolvedOutDir, "tailorkit-upload.json"),
       `${JSON.stringify(createTailorKitUploadManifest(logoManifest, Boolean(loaded.config.server), views), null, 2)}
 `,
       "utf-8"
@@ -950,8 +1375,8 @@ var buildApp = async (options = {}) => {
   };
   let firstBuildDone;
   let firstBuildFailed;
-  const firstBuild = new Promise((resolve, reject) => {
-    firstBuildDone = resolve;
+  const firstBuild = new Promise((resolve2, reject) => {
+    firstBuildDone = resolve2;
     firstBuildFailed = reject;
   });
   if (!options.watch) {
@@ -994,6 +1419,7 @@ var buildApp = async (options = {}) => {
     mode: options.mode,
     oxc: { jsx: { importSource: "preact" } },
     plugins: [
+      fileRoutesPlugin(loaded.root),
       instanceExtractionPlugin(loaded.root, Boolean(loaded.config.server), instanceModules),
       {
         name: "tailorkit-browser-server-boundary",
@@ -1001,7 +1427,7 @@ var buildApp = async (options = {}) => {
         async resolveId(id, importer) {
           if (/^(?:@tailorkit\/app\/server$|tailorkit\/(?:server|app\/server)$|effect(?:\/|$))/u.test(
             id
-          ) || importer && path7.resolve(path7.dirname(importer), id) === serverEntry) {
+          ) || importer && path9.resolve(path9.dirname(importer), id) === serverEntry) {
             throw new Error(
               "App server implementations cannot be imported into a browser bundle. Import api from #tailorkit and server types with import type."
             );
@@ -1043,6 +1469,7 @@ var buildApp = async (options = {}) => {
     ],
     root: loaded.root
   }).catch(async (error) => {
+    await fileEntry.close();
     if (serverWatcher && "close" in serverWatcher) await serverWatcher.close();
     throw error;
   });
@@ -1061,23 +1488,26 @@ var buildApp = async (options = {}) => {
         await result.close();
       }
       if (serverWatcher && "close" in serverWatcher) await serverWatcher.close();
+      await fileEntry.close();
       throw error;
     }
-    if (result && "close" in result && serverWatcher && "close" in serverWatcher) {
+    if (result && "close" in result) {
       const clientWatcher = result;
       return {
         on: clientWatcher.on.bind(clientWatcher),
         async close() {
           await clientWatcher.close();
           if (serverWatcher && "close" in serverWatcher) await serverWatcher.close();
+          await fileEntry.close();
         }
       };
     }
   }
+  await fileEntry.close();
   return result;
 };
 function getInstalledPreactVersion(root) {
-  const require2 = createRequire2(path7.join(root, "package.json"));
+  const require2 = createRequire2(path9.join(root, "package.json"));
   try {
     const packageJsonPath = require2.resolve("preact/package.json");
     const packageJson = require2(packageJsonPath);
@@ -1096,5 +1526,6 @@ export {
   buildApp,
   createTailorKitUploadManifest,
   generateAppMigrations,
+  getClientSourceFiles,
   tailorkitUploadManifestSchema
 };