@tailorkit/app 0.1.0-beta.29 → 0.1.0-beta.32

package/dist/builder.js

@@ -1,1531 +0,0 @@
-import {
-  loadTailorKitConfig
-} from "./chunk-L5ECQGR7.js";
-import "./chunk-DA2TE2FW.js";
-
-// src/builder/index.ts
-import path9 from "path";
-import { createRequire as createRequire2 } from "module";
-import { readFile as readFile4, realpath, writeFile as writeFile3 } from "fs/promises";
-
-// ../asset-delivery/dist/logo-validation.mjs
-var maxLogoBytes = 262144;
-var maxLogoDimension = 2048;
-var readPngDimensions = (content) => {
-  if (content.length < 33 || ![
-    137,
-    80,
-    78,
-    71,
-    13,
-    10,
-    26,
-    10
-  ].every((byte, index) => content[index] === byte)) throw new Error("Logo content is not a valid PNG file.");
-  const view = new DataView(content.buffer, content.byteOffset, content.byteLength);
-  const isIhdr = content[12] === 73 && content[13] === 72 && content[14] === 68 && content[15] === 82;
-  if (view.getUint32(8) !== 13 || !isIhdr) throw new Error("Logo content is not a valid PNG file.");
-  return {
-    width: view.getUint32(16),
-    height: view.getUint32(20)
-  };
-};
-var readWebpDimensions = (content) => {
-  const text = (start, end) => new TextDecoder().decode(content.subarray(start, end));
-  if (content.length < 30 || text(0, 4) !== "RIFF" || text(8, 12) !== "WEBP") throw new Error("Logo content is not a valid WebP file.");
-  const view = new DataView(content.buffer, content.byteOffset, content.byteLength);
-  const chunk = text(12, 16);
-  if (chunk === "VP8X") return {
-    width: 1 + view.getUint16(24, true) + (content[26] ?? 0) * 65536,
-    height: 1 + view.getUint16(27, true) + (content[29] ?? 0) * 65536
-  };
-  if (chunk === "VP8L" && content[20] === 47) {
-    const bits = view.getUint32(21, true);
-    return {
-      width: bits % 16384 + 1,
-      height: Math.floor(bits / 16384) % 16384 + 1
-    };
-  }
-  if (chunk === "VP8 " && content[23] === 157 && content[24] === 1 && content[25] === 42) return {
-    width: view.getUint16(26, true) % 16384,
-    height: view.getUint16(28, true) % 16384
-  };
-  throw new Error("Logo content is not a supported WebP file.");
-};
-var validateSvg = (content) => {
-  const svg = new TextDecoder("utf-8", {
-    fatal: true,
-    ignoreBOM: false
-  }).decode(content);
-  if (!/<svg(?:\s|>)/iu.test(svg)) throw new Error("Logo content is not a valid SVG file.");
-  if (/<(?:script|foreignObject|iframe|object|embed)(?:\s|>)/iu.test(svg) || /\son[a-z]+\s*=/iu.test(svg) || /(?:href|src)\s*=\s*["'](?!#)/iu.test(svg) || /(?:@import|url\(\s*(?!["']?#))/iu.test(svg) || /<!DOCTYPE|<!ENTITY|<\?xml-stylesheet/iu.test(svg)) throw new Error("SVG logos cannot contain scripts or external resources.");
-};
-function validateLogoAsset(content, contentType) {
-  if (content.byteLength < 1 || content.byteLength > 262144) throw new Error(`Logo must be between 1 and ${maxLogoBytes} bytes.`);
-  if (contentType === "image/svg+xml") {
-    validateSvg(content);
-    return {};
-  }
-  const dimensions = contentType === "image/png" ? readPngDimensions(content) : readWebpDimensions(content);
-  if (dimensions.width < 1 || dimensions.height < 1 || dimensions.width > 2048 || dimensions.height > 2048) throw new Error(`Raster logos cannot exceed ${maxLogoDimension} by ${maxLogoDimension} pixels.`);
-  return dimensions;
-}
-
-// src/builder/index.ts
-import { build as viteBuild } from "vite";
-
-// src/preact-version.ts
-var MINIMUM_PREACT_MAJOR_VERSION = 11;
-var parsePreactVersion = (version) => {
-  const match = /^(\d+)\./u.exec(version);
-  if (!match?.[1]) {
-    throw new Error(`Unable to parse Preact version "${version}".`);
-  }
-  return {
-    major: Number.parseInt(match[1], 10),
-    version
-  };
-};
-var assertSupportedPreactVersion = (version) => {
-  const check = parsePreactVersion(version);
-  if (check.major < MINIMUM_PREACT_MAJOR_VERSION) {
-    throw new Error(
-      `TailorKit requires Preact ${MINIMUM_PREACT_MAJOR_VERSION}.0.0 or newer, but found ${version}.`
-    );
-  }
-  return check;
-};
-
-// src/builder/client-views.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-
-// src/builder/upload-manifest.ts
-import { z } from "zod";
-var tailorkitUploadManifestSchema = z.object({
-  assets: z.object({
-    client: z.literal("client/client.js"),
-    server: z.literal("server/server.js").optional(),
-    logos: z.object({
-      dark: z.string().regex(/^client\/logo-dark\.(?:png|svg|webp)$/u).optional(),
-      light: z.string().regex(/^client\/logo-light\.(?:png|svg|webp)$/u).optional()
-    }).optional()
-  }),
-  views: z.array(
-    z.object({
-      slot: z.string().min(1).max(255),
-      path: z.string().startsWith("/").max(1024),
-      instances: z.literal(true).optional(),
-      disabled: z.literal(true).optional()
-    })
-  ).max(1e3).optional(),
-  version: z.literal(1)
-});
-var createTailorKitUploadManifest = (logos, server = false, views) => tailorkitUploadManifestSchema.parse({
-  assets: {
-    client: "client/client.js",
-    ...server ? { server: "server/server.js" } : {},
-    ...logos && Object.keys(logos).length > 0 ? { logos } : {}
-  },
-  views,
-  version: 1
-});
-
-// src/builder/client-views.ts
-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("Invalid generated app client: missing slots");
-const instanceResolvers = [];
-const views = Object.entries(client.slots).flatMap(([slot, definitions]) =>
-  Object.entries(definitions).flatMap(([path, view]) => {
-    if (view === false) return [{ slot, path, disabled: true }];
-    const resolver = view?.instances?.resolver;
-    if (resolver !== undefined) instanceResolvers.push({ slot, path, resolver });
-    return [{ slot, path, ...(resolver !== undefined ? { instances: true } : {}) }];
-  })
-);
-process.stdout.write("\\nTAILORKIT_VIEWS=" + JSON.stringify({ views, instanceResolvers }));
-process.exit(0);
-`;
-async function readClientManifest(filename) {
-  try {
-    const { stdout } = await promisify(execFile)(
-      process.execPath,
-      ["--input-type=module", "--eval", inspectClient, filename],
-      { timeout: 1e4, maxBuffer: 2 * 1024 * 1024 }
-    );
-    const result = stdout.slice(
-      stdout.lastIndexOf("\nTAILORKIT_VIEWS=") + "\nTAILORKIT_VIEWS=".length
-    );
-    const manifest = JSON.parse(result);
-    const views = tailorkitUploadManifestSchema.shape.views.unwrap().parse(manifest.views);
-    if (!Array.isArray(manifest.instanceResolvers) || manifest.instanceResolvers.some(
-      (ref) => !ref || typeof ref !== "object" || typeof ref.slot !== "string" || typeof ref.path !== "string" || typeof ref.resolver !== "string" || !/^i[0-9a-f]{24}$/u.test(ref.resolver)
-    )) {
-      throw new Error("Invalid instance resolver references");
-    }
-    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. Check the default exports of your roots, layouts and .view.tsx files.",
-      { cause: error }
-    );
-  }
-}
-
-// src/builder/server.ts
-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
-import { createHash } from "crypto";
-import { readdir, readFile } from "fs/promises";
-import path from "path";
-async function readAppMigrations(directory, optional = false) {
-  const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
-    if (error.code === "ENOENT") {
-      if (optional) return [];
-      throw new Error(
-        `App migrations directory is missing: ${directory}. Run tailorkit db generate and commit migrations before building.`,
-        { cause: error }
-      );
-    }
-    throw error;
-  });
-  const migrations = [];
-  const files = [directory];
-  const names = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
-  for (const name of names) {
-    if (!/^\d{14}_[\w-]+$/u.test(name)) {
-      throw new Error(`Unsupported app migration folder: ${name}. Use Drizzle Kit v1 migrations.`);
-    }
-    const file = path.join(directory, name, "migration.sql");
-    const sql = await readFile(file, "utf8");
-    const statements = sql.split("--> statement-breakpoint").map((part) => part.trim()).filter(Boolean);
-    if (!statements.length) throw new Error(`App migration is empty: ${name}`);
-    migrations.push({
-      id: name,
-      hash: createHash("sha256").update(sql).digest("hex"),
-      statements
-    });
-    files.push(file);
-  }
-  return { migrations, files };
-}
-
-// src/server/bundle.ts
-var runtimeManifest = {
-  apiVersion: 1,
-  requires: ["database", "actions", "database-relations", "tools"]
-};
-
-// 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 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(path3.join(root, "package.json"));
-  for (const directory of require2.resolve.paths("drizzle-kit") ?? []) {
-    const cli = path3.join(directory, "drizzle-kit/bin.cjs");
-    if (await access(cli).then(() => true).catch(() => false)) {
-      return [
-        "--preserve-symlinks-main",
-        cli,
-        "generate",
-        "--dialect",
-        "sqlite",
-        "--schema",
-        appDatabasePaths(root).schema,
-        "--out",
-        output,
-        ...name === void 0 ? [] : ["--name", name]
-      ];
-    }
-  }
-  throw new Error(
-    "Install drizzle-kit and drizzle-orm as dev dependencies, then run tailorkit db generate."
-  );
-}
-
-// src/builder/schema-check.ts
-var run = promisify2(execFile2);
-async function snapshot(directory) {
-  const entries = await readdir2(directory, { withFileTypes: true }).catch((error) => {
-    if (error.code === "ENOENT") return [];
-    throw error;
-  });
-  const latest = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().at(-1);
-  if (!latest) return;
-  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(
-      `Unsupported app schema snapshot: ${filename}. Use Drizzle Kit v1 SQLite migrations.`
-    );
-  }
-  return value;
-}
-function canonical(value) {
-  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
-  if (value && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-async function checkAppSchema(root, migrationsDirectory) {
-  const schema = appDatabasePaths(root).schema;
-  try {
-    await access2(schema);
-  } catch (error) {
-    if (error.code === "ENOENT") return;
-    throw error;
-  }
-  const temporary = await mkdtemp(path4.join(tmpdir(), "tailorkit-schema-check-"));
-  try {
-    const { stdout } = await run(
-      process.execPath,
-      await drizzleGenerateArguments(root, temporary),
-      {
-        cwd: root,
-        timeout: 3e4,
-        maxBuffer: 1024 * 1024,
-        env: { ...process.env, CI: "true" }
-      }
-    ).catch((error) => {
-      throw new Error(
-        `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 ${path4.relative(root, schema)} and run tailorkit db generate.`
-      );
-    }
-    const saved = await snapshot(migrationsDirectory);
-    const expected = (current?.ddl ?? []).map(canonical).sort();
-    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 ${path4.relative(root, schema)}. Run tailorkit db generate, commit the generated files in ${path4.relative(root, migrationsDirectory)}, then build again.`
-      );
-    }
-  } finally {
-    await rm(temporary, { recursive: true, force: true });
-  }
-}
-
-// src/builder/instances.ts
-import { createHash as createHash2 } from "crypto";
-import { readFile as readFile3 } from "fs/promises";
-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"
-]);
-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",
-  "navigator",
-  "localStorage",
-  "sessionStorage"
-]);
-function isNode(value) {
-  return !!value && typeof value === "object" && "type" in value;
-}
-function children(node) {
-  return Object.values(node).flatMap(
-    (value) => Array.isArray(value) ? value.filter(isNode) : isNode(value) ? [value] : []
-  );
-}
-function walk(node, visit, ancestors = []) {
-  visit(node, ancestors);
-  for (const child of children(node)) walk(child, visit, [...ancestors, node]);
-}
-function boundNames(node) {
-  if (!node) return [];
-  switch (node.type) {
-    case "Identifier":
-      return [node.name];
-    case "RestElement":
-      return boundNames(node.argument);
-    case "AssignmentPattern":
-      return boundNames(node.left);
-    case "ArrayPattern":
-      return node.elements.flatMap(boundNames);
-    case "ObjectPattern":
-      return node.properties.flatMap(
-        (p) => boundNames(p.type === "Property" ? p.value : p.argument)
-      );
-    default:
-      return [];
-  }
-}
-function declarations(node) {
-  if (node.type === "VariableDeclaration")
-    return node.declarations.flatMap((d) => boundNames(d.id));
-  if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration")
-    return boundNames(node.id);
-  return [];
-}
-function isFunction(node) {
-  return ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].includes(
-    node.type
-  );
-}
-function freeNames(root) {
-  const references = /* @__PURE__ */ new Set();
-  function pattern(node, scope) {
-    if (node.type === "AssignmentPattern") {
-      visit(node.right, scope);
-      pattern(node.left, scope);
-    } else if (node.type === "ObjectPattern") {
-      for (const p of node.properties) {
-        if (p.type === "Property") {
-          if (p.computed) visit(p.key, scope);
-          pattern(p.value, scope);
-        } else pattern(p.argument, scope);
-      }
-    } else if (node.type === "ArrayPattern") {
-      for (const element of node.elements) if (element) pattern(element, scope);
-    } else if (node.type === "RestElement") pattern(node.argument, scope);
-  }
-  function visit(node, parent) {
-    if (node.type === "Identifier") {
-      if (!parent.has(node.name)) references.add(node.name);
-      return;
-    }
-    if (node.type === "ImportDeclaration") return;
-    if (node.type === "ExportSpecifier") {
-      visit(node.local, parent);
-      return;
-    }
-    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
-      let hoisted2 = function(body) {
-        if (isFunction(body)) return;
-        if (body.type === "VariableDeclaration" && body.kind === "var") {
-          for (const name of declarations(body)) scope.add(name);
-        }
-        for (const child of children(body)) hoisted2(child);
-      };
-      var hoisted = hoisted2;
-      const scope = /* @__PURE__ */ new Set([
-        ...parent,
-        ...boundNames(node.id),
-        ...node.params.flatMap(boundNames)
-      ]);
-      if (node.body) hoisted2(node.body);
-      for (const p of node.params) pattern(p, scope);
-      if (node.body) visit(node.body, scope);
-      return;
-    }
-    if (node.type === "BlockStatement" || node.type === "Program") {
-      const scope = /* @__PURE__ */ new Set([...parent, ...node.body.flatMap(declarations)]);
-      for (const statement of node.body) visit(statement, scope);
-      return;
-    }
-    if (node.type === "VariableDeclarator") {
-      pattern(node.id, parent);
-      if (node.init) visit(node.init, parent);
-      return;
-    }
-    if (node.type === "Property" || node.type === "MethodDefinition" || node.type === "PropertyDefinition") {
-      if (node.computed) visit(node.key, parent);
-      if (node.value) visit(node.value, parent);
-      return;
-    }
-    if (node.type === "MemberExpression") {
-      visit(node.object, parent);
-      if (node.computed) visit(node.property, parent);
-      return;
-    }
-    if (node.type === "CatchClause") {
-      const scope = /* @__PURE__ */ new Set([...parent, ...boundNames(node.param)]);
-      if (node.param) pattern(node.param, scope);
-      visit(node.body, scope);
-      return;
-    }
-    if (node.type === "ForStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement") {
-      const declaration = node.type === "ForStatement" ? node.init : node.left;
-      const scope = /* @__PURE__ */ new Set([...parent, ...declaration ? declarations(declaration) : []]);
-      for (const child of children(node)) visit(child, scope);
-      return;
-    }
-    if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
-      const scope = /* @__PURE__ */ new Set([...parent, ...boundNames(node.id)]);
-      if (node.superClass) visit(node.superClass, scope);
-      visit(node.body, scope);
-      return;
-    }
-    if (node.type === "LabeledStatement") {
-      visit(node.body, parent);
-      return;
-    }
-    if (node.type === "BreakStatement" || node.type === "ContinueStatement") return;
-    for (const child of children(node)) visit(child, parent);
-  }
-  visit(root, /* @__PURE__ */ new Set());
-  return references;
-}
-function property(node, name) {
-  return node.properties.find(
-    (p) => p.type === "Property" && !p.computed && (p.key.type === "Identifier" ? p.key.name === name : p.key.type === "Literal" && p.key.value === name)
-  );
-}
-function parse(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;
-}
-function units(program, source) {
-  const imports = [];
-  const statements = [];
-  for (const statement of program.body) {
-    if (statement.type === "ImportDeclaration") {
-      imports.push(statement);
-      continue;
-    }
-    const exported = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration";
-    const node = statement.type === "ExportNamedDeclaration" && statement.declaration ? statement.declaration : statement;
-    if (node.type === "VariableDeclaration") {
-      for (const d of node.declarations)
-        statements.push({
-          node: d,
-          names: boundNames(d.id),
-          code: `${exported ? "export " : ""}${node.kind} ${source.slice(d.start, d.end)};`,
-          exported
-        });
-    } else
-      statements.push({
-        node,
-        names: declarations(node),
-        code: source.slice(statement.start, statement.end),
-        exported
-      });
-  }
-  return { imports, statements };
-}
-function closure(roots, statements) {
-  const bindings = new Map(statements.flatMap((u) => u.names.map((name) => [name, u])));
-  const names = /* @__PURE__ */ new Set();
-  const selected = /* @__PURE__ */ new Set();
-  function add(name) {
-    if (names.has(name)) return;
-    names.add(name);
-    const unit = bindings.get(name);
-    if (!unit || selected.has(unit)) return;
-    selected.add(unit);
-    for (const ref of freeNames(unit.node)) add(ref);
-  }
-  for (const root of roots) add(root);
-  return { names, selected };
-}
-function renderImports(imports, needed, source, sideEffects) {
-  return imports.flatMap((i) => {
-    if (!i.specifiers.length) return sideEffects ? [source.slice(i.start, i.end)] : [];
-    const parts = i.specifiers.filter((s) => needed(s.local.name));
-    if (!parts.length) return [];
-    const defaultImport = parts.find((s) => s.type === "ImportDefaultSpecifier");
-    const namespace = parts.find((s) => s.type === "ImportNamespaceSpecifier");
-    const named = parts.filter((s) => s.type === "ImportSpecifier");
-    const clauses = [
-      defaultImport?.local.name,
-      namespace ? `* as ${namespace.local.name}` : void 0,
-      named.length ? `{ ${named.map((s) => `${source.slice(s.imported.start, s.imported.end)} as ${s.local.name}`).join(", ")} }` : void 0
-    ].filter(Boolean);
-    return [`import ${clauses.join(", ")} from ${JSON.stringify(i.source.value)};`];
-  }).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 isDefineViewCall = createDefineViewMatcher(program);
-  let resolvers = [];
-  walk(program, (node, ancestors) => {
-    if (!isDefineViewCall(node)) {
-      return;
-    }
-    const options = node.arguments[0];
-    if (options?.type !== "ObjectExpression") return;
-    const instances = property(options, "instances");
-    if (!instances) return;
-    const fail = (message) => {
-      throw new Error(`${filename}: ${message}`);
-    };
-    if (ancestors.some(isFunction))
-      fail("defineView with instances must be declared at module scope.");
-    const owner = ancestors.findLast((n) => n.type === "VariableDeclarator");
-    const viewName = owner?.type === "VariableDeclarator" && owner.id.type === "Identifier" ? owner.id.name : "default";
-    const view = property(options, "view")?.value;
-    if (view?.type !== "Literal" || typeof view.value !== "string")
-      fail("Instance view paths must be string literals.");
-    if (instances.value.type !== "ObjectExpression")
-      fail("instances must be an inline object with dataSchema and resolve.");
-    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 resolve2 = property(config, "resolve");
-    const schema = property(config, "dataSchema");
-    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(
-      `${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.");
-    resolvers.push({
-      name,
-      view: view.value,
-      call: node,
-      instances,
-      resolve: resolve2,
-      schema
-    });
-  });
-  if (includedNames) {
-    resolvers = resolvers.filter((r) => includedNames.includes(r.name));
-    if (resolvers.length !== includedNames.length)
-      throw new Error(`${filename}: Instance definitions changed; rebuild the app client.`);
-  }
-  if (!resolvers.length) return;
-  const original = units(program, source);
-  const server = closure(
-    resolvers.flatMap((r) => [...freeNames(r.resolve.value), ...freeNames(r.schema.value)]),
-    original.statements
-  );
-  for (const name of server.names) {
-    if (browserGlobals.has(name))
-      throw new Error(`${filename}: Instance resolvers cannot access browser global ${name}.`);
-  }
-  for (const unit of server.selected) {
-    if (resolvers.some((r) => unit.node.start <= r.call.start && unit.node.end >= r.call.end))
-      throw new Error(
-        `${filename}: Instance resolvers cannot capture a view definition. Use the supplied context and queries.`
-      );
-  }
-  const serverSource = [
-    renderImports(original.imports, (name) => server.names.has(name), source, false),
-    ...original.statements.filter((u) => server.selected.has(u)).map((u) => u.code.replace(/^export /u, "")),
-    `export const resolvers = { ${resolvers.map((r) => `${r.name}: { dataSchema: ${source.slice(r.schema.value.start, r.schema.value.end)}, resolve: ${source.slice(r.resolve.value.start, r.resolve.value.end)} }`).join(", ")} };`
-  ].join("\n");
-  let browserSource = source;
-  for (const r of [...resolvers].sort(
-    (a, b) => b.instances.value.start - a.instances.value.start
-  )) {
-    browserSource = browserSource.slice(0, r.instances.value.start) + `{ resolver: ${JSON.stringify(r.name)} }` + browserSource.slice(r.instances.value.end);
-  }
-  const browser = units(parse("browser.js", browserSource), browserSource);
-  const serverBindings = new Set([...server.selected].flatMap((u) => u.names));
-  const browserRoots = browser.statements.filter(
-    (u) => u.exported || !u.names.length || !u.names.some((name) => serverBindings.has(name))
-  );
-  const browserNeeded = closure(
-    browserRoots.flatMap((u) => [...freeNames(u.node), ...u.names]),
-    browser.statements
-  );
-  return {
-    names: resolvers.map((r) => r.name),
-    server: serverSource,
-    browser: [
-      renderImports(
-        browser.imports,
-        (name) => !server.names.has(name) || browserNeeded.names.has(name),
-        browserSource,
-        true
-      ),
-      ...browser.statements.filter((u) => browserRoots.includes(u) || browserNeeded.selected.has(u)).map((u) => u.code)
-    ].join("\n")
-  };
-}
-function instanceExtractionPlugin(root, serverConfigured, modules) {
-  return {
-    name: "tailorkit-instance-extraction",
-    enforce: "pre",
-    async transform(source, filename) {
-      if (filename.includes("node_modules") || !/\.[cm]?[jt]sx?$/u.test(filename) || !source.includes("instances") && !modules.has(filename))
-        return;
-      const result = await extractInstances(filename, source, root);
-      if (!result) {
-        modules.delete(filename);
-        return;
-      }
-      if (!serverConfigured)
-        throw new Error("View instances require server configuration in tailorkit.config.ts.");
-      modules.set(filename, { filename, names: result.names });
-      return { code: result.browser, map: null };
-    }
-  };
-}
-function instanceServerPlugin(root, modules) {
-  return {
-    name: "tailorkit-instance-server-modules",
-    enforce: "pre",
-    resolveId(id) {
-      if (id.endsWith(suffix)) return id;
-    },
-    async load(id) {
-      if (!id.endsWith(suffix)) return;
-      const filename = id.slice(0, -suffix.length);
-      this.addWatchFile(filename);
-      const names = modules.find((module) => module.filename === filename)?.names;
-      const result = await extractInstances(
-        filename,
-        await readFile3(filename, "utf8"),
-        root,
-        names
-      );
-      if (!result)
-        throw new Error(`Instance resolver missing from ${filename}; rebuild the app client.`);
-      return result.server;
-    }
-  };
-}
-function instanceServerImports(modules) {
-  return modules.map(
-    (m, i) => `import { resolvers as instances${i} } from ${JSON.stringify(m.filename + suffix)};`
-  ).join("\n");
-}
-function instanceServerBindings(modules, registrations) {
-  return `[${registrations.map(({ slot, path: viewPath, resolver }) => {
-    const index = modules.findIndex((module) => module.names.includes(resolver));
-    if (index < 0) throw new Error("Instance resolver was not extracted by the app build.");
-    return `{ slot: ${JSON.stringify(slot)}, path: ${JSON.stringify(viewPath)}, ...instances${index}[${JSON.stringify(resolver)}] }`;
-  }).join(", ")}]`;
-}
-
-// src/builder/server.ts
-async function buildServer(loaded, watch2 = false, buildOutDir, instances = [], registrations = []) {
-  const config = loaded.config.server;
-  if (!config) {
-    return;
-  }
-  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 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 = watch2 ? new Promise((resolve2) => {
-    ready = resolve2;
-  }) : void 0;
-  try {
-    await writeFile2(
-      entry,
-      `${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(path7.resolve(loaded.root, config.entry ?? "src/server.ts"))};`}
-export { default as migrations } from "tailorkit:migrations";
-export const runtimeManifest = ${JSON.stringify(runtimeManifest)};
-`
-    );
-    const result = await build({
-      root: loaded.root,
-      configFile: false,
-      plugins: [
-        instanceServerPlugin(loaded.root, instances),
-        {
-          name: "tailorkit-app-migrations",
-          closeWatcher: () => rm3(temporary, { recursive: true, force: true }),
-          resolveId(id) {
-            if (id === "tailorkit:migrations") {
-              return "\0tailorkit:migrations";
-            }
-          },
-          async load(id) {
-            if (id !== "\0tailorkit:migrations") {
-              return;
-            }
-            const { migrations, files } = await readAppMigrations(
-              migrationsDirectory,
-              config.migrations === void 0
-            );
-            await checkAppSchema(loaded.root, migrationsDirectory);
-            this.addWatchFile(appDatabasePaths(loaded.root).schema);
-            for (const file of files) {
-              this.addWatchFile(file);
-            }
-            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") {
-                  return;
-                }
-                throw error;
-              }
-            );
-            return `export default ${JSON.stringify(migrations)};`;
-          }
-        }
-      ],
-      build: {
-        ssr: entry,
-        outDir: directory,
-        emptyOutDir: false,
-        target: "es2022",
-        watch: watch2 ? {} : null,
-        minify: "oxc",
-        rollupOptions: {
-          external: [],
-          output: {
-            entryFileNames: "server.js",
-            inlineDynamicImports: true,
-            minify: true,
-            minifyInternalExports: true
-          }
-        }
-      },
-      ssr: { noExternal: true }
-    });
-    watching = watch2;
-    if (watch2 && "on" in result && initialBuild) {
-      try {
-        await Promise.race([
-          initialBuild,
-          new Promise(
-            (_, reject) => result.on("event", (event) => {
-              if (event.code === "ERROR") reject(event.error);
-              if (event.code === "END") ready?.();
-            })
-          )
-        ]);
-      } catch (error) {
-        await result.close();
-        throw error;
-      }
-    }
-    return result;
-  } finally {
-    if (!watching) await rm3(temporary, { recursive: true, force: true });
-  }
-}
-function validateServerBuildOutput(loaded, output) {
-  if (!loaded.config.server) return;
-  const migrationsDirectory = appDatabasePaths(
-    loaded.root,
-    loaded.config.server.migrations
-  ).migrations;
-  for (const name of ["server", "client", "migrations", "tmp"]) {
-    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 = path7.relative(parent, child);
-    return relative === "" || !path7.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path7.sep}`);
-  };
-  return contains(source, destination) || contains(destination, source);
-}
-
-// src/builder/generate-migrations.ts
-import { spawn } from "child_process";
-import { access as access3 } from "fs/promises";
-import path8 from "path";
-async function generateAppMigrations(options = {}) {
-  const loaded = await loadTailorKitConfig(options.configPath, options.cwd);
-  if (!loaded.config.server) {
-    throw new Error(
-      "Enable server: {} in tailorkit.config.ts before generating database migrations."
-    );
-  }
-  const paths = appDatabasePaths(loaded.root, loaded.config.server.migrations);
-  await access3(paths.schema).catch((error) => {
-    throw new Error(
-      `Define the app database schema in ${path8.relative(loaded.root, paths.schema)} before generating migrations.`,
-      { cause: error }
-    );
-  });
-  const directory = paths.migrations;
-  const args = await drizzleGenerateArguments(loaded.root, directory, options.name);
-  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) resolve2();
-      else reject(new Error(`Drizzle migration generation failed (${signal ?? code}).`));
-    });
-  });
-  await checkAppSchema(loaded.root, directory);
-  return directory;
-}
-
-// src/builder/index.ts
-var preactPackageJson = "preact/package.json";
-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 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 = path9.resolve(loaded.root, outDir);
-  validateServerBuildOutput(loaded, resolvedOutDir);
-  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(
-      path9.join(clientOutDir, "client.js")
-    );
-    const resolverNames = new Set(instanceResolvers.map((registration) => registration.resolver));
-    const activeModules = [...instanceModules.values()].map((module) => ({
-      ...module,
-      names: module.names.filter((name) => resolverNames.has(name))
-    })).filter((module) => module.names.length).sort((a, b) => a.filename.localeCompare(b.filename));
-    if (activeModules.reduce((count, module) => count + module.names.length, 0) !== resolverNames.size) {
-      throw new Error(
-        "Client references an instance resolver that was not extracted by the app build."
-      );
-    }
-    if (serverWatcher && "close" in serverWatcher) await serverWatcher.close();
-    serverWatcher = await buildServer(
-      loaded,
-      options.watch,
-      resolvedOutDir,
-      activeModules,
-      instanceResolvers
-    );
-    const logoManifest = {};
-    for (const variant of ["light", "dark"]) {
-      const configuredPath = loaded.config.logos?.[variant];
-      if (!configuredPath) {
-        continue;
-      }
-      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(path9.resolve(loaded.root, configuredPath));
-      validateLogoAsset(content, contentType);
-      const filename = `logo-${variant}.${extension}`;
-      await writeFile3(path9.join(clientOutDir, filename), content);
-      logoManifest[variant] = `client/${filename}`;
-    }
-    await writeFile3(path9.join(clientOutDir, "views.json"), `${JSON.stringify(views)}
-`);
-    await writeFile3(
-      path9.join(resolvedOutDir, "tailorkit-upload.json"),
-      `${JSON.stringify(createTailorKitUploadManifest(logoManifest, Boolean(loaded.config.server), views), null, 2)}
-`,
-      "utf-8"
-    );
-  };
-  let firstBuildDone;
-  let firstBuildFailed;
-  const firstBuild = new Promise((resolve2, reject) => {
-    firstBuildDone = resolve2;
-    firstBuildFailed = reject;
-  });
-  if (!options.watch) {
-    void firstBuild.catch(() => {
-    });
-  }
-  const completeBuild = async () => {
-    try {
-      await writeBuildExtras();
-      firstBuildDone?.();
-    } catch (error) {
-      firstBuildFailed?.(error instanceof Error ? error : new Error(String(error)));
-      throw error;
-    }
-  };
-  const result = await viteBuild({
-    build: {
-      emptyOutDir: true,
-      lib: {
-        entry,
-        fileName: "client",
-        formats: ["es"]
-      },
-      outDir: clientOutDir,
-      watch: options.watch ? {} : null,
-      minify: "oxc",
-      rollupOptions: {
-        output: {
-          comments: {
-            annotation: false,
-            jsdoc: false,
-            legal: false
-          },
-          minify: true,
-          minifyInternalExports: true
-        }
-      }
-    },
-    configFile: false,
-    mode: options.mode,
-    oxc: { jsx: { importSource: "preact" } },
-    plugins: [
-      fileRoutesPlugin(loaded.root),
-      instanceExtractionPlugin(loaded.root, Boolean(loaded.config.server), instanceModules),
-      {
-        name: "tailorkit-browser-server-boundary",
-        enforce: "pre",
-        async resolveId(id, importer) {
-          if (/^(?:@tailorkit\/app\/server$|tailorkit\/(?:server|app\/server)$|effect(?:\/|$))/u.test(
-            id
-          ) || 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."
-            );
-          }
-          if (importer) {
-            const resolved = await this.resolve(id, importer, { skipSelf: true });
-            if (resolved?.id.split("?")[0] === serverEntry) {
-              throw new Error(
-                "App server implementations cannot be imported into a browser bundle. Import api from #tailorkit and server types with import type."
-              );
-            }
-          }
-          return null;
-        }
-      },
-      {
-        name: "tailorkit-preview-build-ready",
-        async writeBundle() {
-          await completeBuild();
-        }
-      },
-      {
-        name: "tailorkit-preact-package-json",
-        enforce: "pre",
-        resolveId(id) {
-          if (id === preactPackageJson) {
-            return preactPackageJsonModuleId;
-          }
-          return null;
-        },
-        load(id) {
-          if (id === preactPackageJsonModuleId) {
-            const version = JSON.stringify(preactVersion);
-            return `export const version = ${version}; export default { version: ${version} };`;
-          }
-          return null;
-        }
-      }
-    ],
-    root: loaded.root
-  }).catch(async (error) => {
-    await fileEntry.close();
-    if (serverWatcher && "close" in serverWatcher) await serverWatcher.close();
-    throw error;
-  });
-  if (options.watch) {
-    if (result && typeof result === "object" && "on" in result) {
-      result.on("event", (event) => {
-        if (event.code === "ERROR") {
-          firstBuildFailed?.(event.error ?? new Error("Initial app build failed."));
-        }
-      });
-    }
-    try {
-      await firstBuild;
-    } catch (error) {
-      if (result && typeof result === "object" && "close" in result) {
-        await result.close();
-      }
-      if (serverWatcher && "close" in serverWatcher) await serverWatcher.close();
-      await fileEntry.close();
-      throw error;
-    }
-    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(path9.join(root, "package.json"));
-  try {
-    const packageJsonPath = require2.resolve("preact/package.json");
-    const packageJson = require2(packageJsonPath);
-    if (typeof packageJson.version === "string") {
-      return packageJson.version;
-    }
-  } catch (error) {
-    throw new Error(
-      `TailorKit requires Preact to build an app. Install preact@^11 and try again.`,
-      { cause: error }
-    );
-  }
-  throw new Error("Unable to read the installed Preact version.");
-}
-export {
-  buildApp,
-  createTailorKitUploadManifest,
-  generateAppMigrations,
-  getClientSourceFiles,
-  tailorkitUploadManifestSchema
-};