@tailorkit/app 0.1.0-beta.2 → 0.1.0-beta.20

package/dist/builder.js

@@ -1,12 +1,77 @@
 import {
   loadTailorKitConfig
-} from "./chunk-7L6ZZHCK.js";
-import "./chunk-AGGRUUWG.js";
+} from "./chunk-DEU6RITM.js";
+import "./chunk-GVB2PAK7.js";
+
+// src/builder/index.ts
+import path7 from "path";
+import { createRequire as createRequire2 } from "module";
+import { readFile as readFile4, realpath, writeFile as writeFile2 } 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 path from "path";
-import { createRequire } from "module";
-import { writeFile } from "fs/promises";
 import { build as viteBuild } from "vite";
 
 // src/preact-version.ts
@@ -31,45 +96,889 @@ var assertSupportedPreactVersion = (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.js")
+    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 = () => tailorkitUploadManifestSchema.parse({
+var createTailorKitUploadManifest = (logos, server = false, views) => tailorkitUploadManifestSchema.parse({
   assets: {
-    client: "client.js"
+    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("Client must default-export defineClient(...)");
+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, and default-export defineClient(...).",
+      { cause: error }
+    );
+  }
+}
+
+// src/builder/server.ts
+import { mkdir, mkdtemp as mkdtemp2, writeFile, cp, rm as rm2 } from "fs/promises";
+import path5 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"]
+};
+
+// 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 { promisify as promisify2 } from "util";
+
+// src/builder/drizzle.ts
+import { access } from "fs/promises";
+import { createRequire } from "module";
+import path2 from "path";
+async function drizzleGenerateArguments(root, output, name) {
+  const require2 = createRequire(path2.join(root, "package.json"));
+  for (const directory of require2.resolve.paths("drizzle-kit") ?? []) {
+    const cli = path2.join(directory, "drizzle-kit/bin.cjs");
+    if (await access(cli).then(() => true).catch(() => false)) {
+      return [
+        "--preserve-symlinks-main",
+        cli,
+        "generate",
+        "--dialect",
+        "sqlite",
+        "--schema",
+        path2.join(root, "src/schema.ts"),
+        "--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 = path3.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 = path3.join(root, "src/schema.ts");
+  try {
+    await access2(schema);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  const temporary = await mkdtemp(path3.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 src/schema.ts 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."
+      );
+    }
+    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 src/schema.ts. Run tailorkit db generate, commit the generated files in ${path3.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 path4 from "path";
+import { parseSync, transformWithOxc } from "vite";
+var suffix = "?tailorkit-instances";
+var clientImports = /* @__PURE__ */ new Set([
+  "tailorkit/client",
+  "tailorkit/app/client",
+  "@tailorkit/app/client"
+]);
+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 = parseSync(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) {
+  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);
+    }
+  }
+  let resolvers = [];
+  walk(program, (node, ancestors) => {
+    if (node.type !== "CallExpression" || node.callee.type !== "Identifier" || !aliases.has(node.callee.name))
+      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 resolve = property(config, "resolve");
+    const schema = property(config, "dataSchema");
+    if (!resolve || !schema || resolve.method || !["ArrowFunctionExpression", "FunctionExpression"].includes(resolve.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}`
+    ).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,
+      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, watch = 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");
+  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");
+  let watching = false;
+  let ready;
+  const initialBuild = watch ? new Promise((resolve) => {
+    ready = resolve;
+  }) : void 0;
+  try {
+    await writeFile(
+      entry,
+      `${instances.length ? `import app from ${JSON.stringify(path5.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 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: () => rm2(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(path5.join(loaded.root, "src/schema.ts"));
+            for (const file of files) {
+              this.addWatchFile(file);
+            }
+            await rm2(migrationsOutput, { recursive: true, force: true });
+            await mkdir(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: watch ? {} : null,
+        minify: "oxc",
+        rollupOptions: {
+          external: [],
+          output: {
+            entryFileNames: "server.js",
+            inlineDynamicImports: true,
+            minify: true,
+            minifyInternalExports: true
+          }
+        }
+      },
+      ssr: { noExternal: true }
+    });
+    watching = watch;
+    if (watch && "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 rm2(temporary, { recursive: true, force: true });
+  }
+}
+function validateServerBuildOutput(loaded, output) {
+  if (!loaded.config.server) return;
+  const migrationsDirectory = path5.resolve(
+    loaded.root,
+    loaded.config.server.migrations ?? "./migrations"
+  );
+  for (const name of ["server", "client", "migrations", "tmp"]) {
+    if (overlaps(migrationsDirectory, path5.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}`);
+  };
+  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 path6 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."
+    );
+  }
+  await access3(path6.join(loaded.root, "src/schema.ts")).catch((error) => {
+    throw new Error(
+      "Define the app database schema in src/schema.ts before generating migrations.",
+      { cause: error }
+    );
+  });
+  const directory = path6.resolve(loaded.root, loaded.config.server.migrations ?? "./migrations");
+  const args = await drizzleGenerateArguments(loaded.root, directory, options.name);
+  await new Promise((resolve, 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();
+      else reject(new Error(`Drizzle migration generation failed (${signal ?? code}).`));
+    });
+  });
+  await checkAppSchema(loaded.root, directory);
+  return directory;
+}
+
 // src/builder/index.ts
-var preactExternal = /^preact(?:\/.*)?$/u;
 var preactPackageJson = "preact/package.json";
 var preactPackageJsonModuleId = "\0tailorkit-preact-package-json";
 var buildApp = async (options = {}) => {
   const loaded = await loadTailorKitConfig(options.configPath, options.cwd);
-  const entry = options.entry ?? loaded.config.client?.entry ?? "./src/client.ts";
+  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 outDir = options.outDir ?? loaded.config.build?.outDir ?? ".tailorkit";
   const preactVersion = getInstalledPreactVersion(loaded.root);
   assertSupportedPreactVersion(preactVersion);
-  const resolvedOutDir = path.resolve(loaded.root, outDir);
+  const resolvedOutDir = path7.resolve(loaded.root, outDir);
+  validateServerBuildOutput(loaded, resolvedOutDir);
+  const clientOutDir = path7.join(resolvedOutDir, "client");
+  const instanceModules = /* @__PURE__ */ new Map();
+  let serverWatcher;
+  const writeBuildExtras = async () => {
+    const { views, instanceResolvers } = await readClientManifest(
+      path7.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 = path7.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));
+      validateLogoAsset(content, contentType);
+      const filename = `logo-${variant}.${extension}`;
+      await writeFile2(path7.join(clientOutDir, filename), content);
+      logoManifest[variant] = `client/${filename}`;
+    }
+    await writeFile2(path7.join(clientOutDir, "views.json"), `${JSON.stringify(views)}
+`);
+    await writeFile2(
+      path7.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((resolve, reject) => {
+    firstBuildDone = resolve;
+    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: path.resolve(loaded.root, entry),
+        entry,
         fileName: "client",
         formats: ["es"]
       },
-      outDir: resolvedOutDir,
+      outDir: clientOutDir,
       watch: options.watch ? {} : null,
       minify: "oxc",
       rollupOptions: {
-        external: (id) => id !== preactPackageJson && id !== preactPackageJsonModuleId && preactExternal.test(id),
         output: {
           comments: {
             annotation: false,
@@ -83,7 +992,37 @@ var buildApp = async (options = {}) => {
     },
     configFile: false,
     mode: options.mode,
+    oxc: { jsx: { importSource: "preact" } },
     plugins: [
+      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 && path7.resolve(path7.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",
@@ -103,17 +1042,42 @@ var buildApp = async (options = {}) => {
       }
     ],
     root: loaded.root
+  }).catch(async (error) => {
+    if (serverWatcher && "close" in serverWatcher) await serverWatcher.close();
+    throw error;
   });
-  await writeFile(
-    path.join(resolvedOutDir, "tailorkit-upload.json"),
-    `${JSON.stringify(createTailorKitUploadManifest(), null, 2)}
-`,
-    "utf-8"
-  );
+  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();
+      throw error;
+    }
+    if (result && "close" in result && serverWatcher && "close" in serverWatcher) {
+      const clientWatcher = result;
+      return {
+        on: clientWatcher.on.bind(clientWatcher),
+        async close() {
+          await clientWatcher.close();
+          if (serverWatcher && "close" in serverWatcher) await serverWatcher.close();
+        }
+      };
+    }
+  }
   return result;
 };
 function getInstalledPreactVersion(root) {
-  const require2 = createRequire(path.join(root, "package.json"));
+  const require2 = createRequire2(path7.join(root, "package.json"));
   try {
     const packageJsonPath = require2.resolve("preact/package.json");
     const packageJson = require2(packageJsonPath);
@@ -131,5 +1095,6 @@ function getInstalledPreactVersion(root) {
 export {
   buildApp,
   createTailorKitUploadManifest,
+  generateAppMigrations,
   tailorkitUploadManifestSchema
 };