@tailorkit/vite 0.0.0-stage → 0.1.0-beta.32

package/dist/index.mjs

@@ -0,0 +1,788 @@
+import { a as createDefineViewMatcher, c as getBuildEnvironment, d as createTailorKitUploadManifest, f as tailorkitUploadManifestSchema, i as inferFileView, n as fileRoutesPlugin, o as checkAppSchema, s as isMissingFile, t as createFileRouteEntry, u as appDatabasePaths } from "./file-routes-CjOIw7fH.mjs";
+import { loadTailorKitConfig } from "./config-loader.mjs";
+import { createRequire } from "node:module";
+import { z } from "zod";
+import { execFile } from "node:child_process";
+import { cp, mkdir, mkdtemp, readFile, readdir, realpath, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { build, parseSync, transformWithOxc } from "vite";
+import { createHash } from "node:crypto";
+//#region ../asset-delivery/dist/logo-validation.mjs
+const maxLogoBytes = 262144;
+const maxLogoDimension = 2048;
+const 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 {
+		height: view.getUint32(20),
+		width: view.getUint32(16)
+	};
+};
+const 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 {
+		height: 1 + view.getUint16(27, true) + (content[29] ?? 0) * 65536,
+		width: 1 + view.getUint16(24, true) + (content[26] ?? 0) * 65536
+	};
+	if (chunk === "VP8L" && content[20] === 47) {
+		const bits = view.getUint32(21, true);
+		return {
+			height: Math.floor(bits / 16384) % 16384 + 1,
+			width: bits % 16384 + 1
+		};
+	}
+	if (chunk === "VP8 " && content[23] === 157 && content[24] === 1 && content[25] === 42) return {
+		height: view.getUint16(28, true) % 16384,
+		width: view.getUint16(26, true) % 16384
+	};
+	throw new Error("Logo content is not a supported WebP file.");
+};
+const 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.");
+};
+const 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;
+};
+//#endregion
+//#region src/builder/client-views.ts
+const 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);
+`;
+const readClientManifest = async (filename) => {
+	try {
+		const { stdout } = await promisify(execFile)(process.execPath, [
+			"--input-type=module",
+			"--eval",
+			inspectClient,
+			filename
+		], {
+			maxBuffer: 2097152,
+			timeout: 1e4
+		});
+		const result = stdout.slice(stdout.lastIndexOf("\nTAILORKIT_VIEWS=") + 17);
+		return z.object({
+			instanceResolvers: z.array(z.object({
+				path: z.string(),
+				resolver: z.string().regex(/^i[0-9a-f]{24}$/u),
+				slot: z.string()
+			})),
+			views: tailorkitUploadManifestSchema.shape.views.unwrap()
+		}).parse(JSON.parse(result));
+	} 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 });
+	}
+};
+//#endregion
+//#region src/builder/instances.ts
+const isStringValue = (value) => typeof value === "string";
+const requireValue$1 = (value) => {
+	if (value === null || value === void 0) throw new Error("Expected a defined value.");
+	return value;
+};
+const suffix = "?tailorkit-instances";
+const browserGlobals = /* @__PURE__ */ new Set([
+	"window",
+	"document",
+	"navigator",
+	"localStorage",
+	"sessionStorage"
+]);
+const isNode = (value) => value !== void 0 && value !== null && value !== false && value !== "" && value !== 0 && !Number.isNaN(value) && value !== 0n && typeof value === "object" && "type" in value;
+const children = (node) => Object.values(node).flatMap((value) => (() => {
+	if (Array.isArray(value)) return value.filter(isNode);
+	if (isNode(value)) return [value];
+	return [];
+})());
+const walk = (node, visit, ancestors = []) => {
+	visit(node, ancestors);
+	for (const child of children(node)) walk(child, visit, [...ancestors, node]);
+};
+const 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 [];
+	}
+};
+const 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 [];
+};
+const isFunction = (node) => [
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+].includes(node.type);
+/** Lexical references, excluding property names and bindings local to a function/block. */
+const freeNames = (root) => {
+	const references = /* @__PURE__ */ new Set();
+	const 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") {
+			const scope = /* @__PURE__ */ new Set([
+				...parent,
+				...boundNames(node.id),
+				...node.params.flatMap(boundNames)
+			]);
+			const hoisted = (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)) hoisted(child);
+			};
+			if (node.body) hoisted(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);
+	};
+	const 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);
+	};
+	visit(root, /* @__PURE__ */ new Set());
+	return references;
+};
+const property = (node, name) => 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));
+const 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;
+};
+const 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({
+			code: `${exported ? "export " : ""}${node.kind} ${source.slice(d.start, d.end)};`,
+			exported,
+			names: boundNames(d.id),
+			node: d
+		});
+		else statements.push({
+			code: source.slice(statement.start, statement.end),
+			exported,
+			names: declarations(node),
+			node
+		});
+	}
+	return {
+		imports,
+		statements
+	};
+};
+const 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();
+	const 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
+	};
+};
+const renderImports = (imports, needed, source, sideEffects) => 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");
+	return [`import ${[
+		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).join(", ")} from ${JSON.stringify(i.source.value)};`];
+}).join("\n");
+const extractInstances = async (filename, initialSource, root, includedNames) => {
+	let source = initialSource;
+	source = inferFileView(source, filename, root);
+	source = (await transformWithOxc(source, filename, {
+		jsx: { importSource: "preact" },
+		sourcemap: false
+	})).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;
+		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" || !isStringValue(view.value)) 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${createHash("sha256").update(`${path.relative(root, filename).split(path.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({
+			call: node,
+			instances,
+			name,
+			resolve: requireValue$1(resolve),
+			schema: requireValue$1(schema),
+			view: view.value
+		});
+	});
+	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].toSorted((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 {
+		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"),
+		names: resolvers.map((r) => r.name),
+		server: serverSource
+	};
+};
+const instanceExtractionPlugin = (root, serverConfigured, modules) => ({
+	enforce: "pre",
+	name: "tailorkit-instance-extraction",
+	transform: async (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
+		};
+	}
+});
+const instanceServerPlugin = (root, modules) => ({
+	enforce: "pre",
+	async load(id) {
+		if (!id.endsWith(suffix)) return;
+		const filename = id.slice(0, -20);
+		this.addWatchFile(filename);
+		const names = modules.find((module) => module.filename === filename)?.names;
+		const result = await extractInstances(filename, await readFile(filename, "utf-8"), root, names);
+		if (!result) throw new Error(`Instance resolver missing from ${filename}; rebuild the app client.`);
+		return result.server;
+	},
+	name: "tailorkit-instance-server-modules",
+	resolveId: (id) => id.endsWith(suffix) ? id : void 0
+});
+const instanceServerImports = (modules) => modules.map((m, i) => `import { resolvers as instances${i} } from ${JSON.stringify(m.filename + suffix)};`).join("\n");
+const instanceServerBindings = (modules, registrations) => `[${registrations.map(({ slot, path: viewPath, resolver }) => {
+	const index = modules.findIndex((module) => module.names.includes(resolver));
+	if (index === -1) 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(", ")}]`;
+//#endregion
+//#region src/builder/migrations.ts
+/** Read the timestamped migration folders produced by the workspace's Drizzle Kit version. */
+const readAppMigrations = async (directory, optional = false) => {
+	const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+		if (isMissingFile(error)) {
+			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).toSorted();
+	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, "utf-8");
+		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({
+			hash: createHash("sha256").update(sql).digest("hex"),
+			id: name,
+			statements
+		});
+		files.push(file);
+	}
+	return {
+		files,
+		migrations
+	};
+};
+//#endregion
+//#region src/builder/server.ts
+const containsImplementation = (parent, child) => {
+	const relative = path.relative(parent, child);
+	return relative === "" || !path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`);
+};
+const overlaps = (source, destination) => {
+	const contains = containsImplementation;
+	return contains(source, destination) || contains(destination, source);
+};
+/** Check before either build can empty an output directory. */
+const 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, path.join(output, name))) throw new Error("App build output must not overlap migration source");
+};
+/** Emitted by this SDK's builder; breaking interface changes increment apiVersion. */
+const runtimeManifest = {
+	apiVersion: 1,
+	requires: [
+		"database",
+		"actions",
+		"database-relations",
+		"tools"
+	]
+};
+/** Bundle the private app backend and migrations. */
+const buildServer = async (loaded, watch = false, buildOutDir, instances = [], registrations = [], viteConfig = {}) => {
+	const config = loaded.config.server;
+	if (!config) return;
+	const output = buildOutDir ?? path.resolve(loaded.root, ".tailorkit");
+	const directory = path.join(output, "server");
+	const migrationsDirectory = appDatabasePaths(loaded.root, config.migrations).migrations;
+	const migrationsOutput = path.join(output, "migrations");
+	const temporaryRoot = path.join(output, "tmp");
+	validateServerBuildOutput(loaded, output);
+	await rm(directory, {
+		force: true,
+		recursive: true
+	});
+	await mkdir(directory, { recursive: true });
+	await mkdir(temporaryRoot, { recursive: true });
+	const temporary = await mkdtemp(path.join(temporaryRoot, "server-"));
+	const entry = path.join(temporary, "entry.mjs");
+	let watching = false;
+	let ready;
+	const initialBuild = watch ? (async () => {
+		const { promise: pendingPromise, resolve, reject: rejectPending } = Promise.withResolvers();
+		try {
+			ready = resolve;
+		} catch (error) {
+			rejectPending(error);
+		}
+		await pendingPromise;
+	})() : void 0;
+	try {
+		await writeFile(entry, `${instances.length ? `import app from ${JSON.stringify(path.resolve(loaded.root, config.entry ?? "src/server.ts"))};\nimport { withInstanceResolvers } from "tailorkit/server";\n${instanceServerImports(instances)}\nexport default withInstanceResolvers(app, ${instanceServerBindings(instances, registrations)});` : `export { default } from ${JSON.stringify(path.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({
+			build: {
+				emptyOutDir: false,
+				minify: "oxc",
+				outDir: directory,
+				rolldownOptions: {
+					external: [],
+					output: {
+						entryFileNames: "server.js",
+						inlineDynamicImports: true,
+						minify: true,
+						minifyInternalExports: true
+					}
+				},
+				ssr: entry,
+				target: "es2022",
+				watch: watch ? {} : null
+			},
+			configFile: false,
+			define: viteConfig.define,
+			mode: viteConfig.mode,
+			plugins: [
+				...viteConfig.plugins ?? [],
+				instanceServerPlugin(loaded.root, instances),
+				{
+					closeWatcher: async () => {
+						await rm(temporary, {
+							force: true,
+							recursive: true
+						});
+					},
+					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 rm(migrationsOutput, {
+							force: true,
+							recursive: true
+						});
+						await mkdir(migrationsOutput, { recursive: true });
+						await cp(migrationsDirectory, migrationsOutput, { recursive: true }).catch((error) => {
+							if (config.migrations === void 0 && isMissingFile(error)) return;
+							throw error;
+						});
+						return `export default ${JSON.stringify(migrations)};`;
+					},
+					name: "tailorkit-app-migrations",
+					resolveId: (id) => id === "tailorkit:migrations" ? "\0tailorkit:migrations" : void 0
+				}
+			],
+			resolve: viteConfig.resolve,
+			root: loaded.root,
+			ssr: { noExternal: true }
+		});
+		watching = watch;
+		if (watch && "on" in result && initialBuild) try {
+			await Promise.race([initialBuild, (async () => {
+				const { promise: pendingPromise, resolve: _, reject } = Promise.withResolvers();
+				try {
+					result.on("event", (event) => {
+						if (event.code === "ERROR") reject(event.error);
+						if (event.code === "END") ready?.();
+					});
+				} catch (error) {
+					reject(error);
+				}
+				return await pendingPromise;
+			})()]);
+		} catch (error) {
+			await result.close();
+			throw error;
+		}
+		return result;
+	} finally {
+		if (!watching) await rm(temporary, {
+			force: true,
+			recursive: true
+		});
+	}
+};
+const parsePreactVersion = (version) => {
+	const match = /^(?<major>\d+)\./u.exec(version);
+	if (!(match?.[1] !== void 0 && match?.[1] !== null && match?.[1] !== "")) throw new Error(`Unable to parse Preact version "${version}".`);
+	return {
+		major: Math.trunc(Number(match[1])),
+		version
+	};
+};
+const assertSupportedPreactVersion = (version) => {
+	const check = parsePreactVersion(version);
+	if (check.major < 11) throw new Error(`TailorKit requires Preact 11.0.0 or newer, but found ${version}.`);
+	return check;
+};
+//#endregion
+//#region src/index.ts
+const requireValue = (value) => {
+	if (value === null || value === void 0) throw new Error("Expected a defined value.");
+	return value;
+};
+const preactPackageJson = "preact/package.json";
+const preactPackageJsonModuleId = "\0tailorkit-preact-package-json";
+const flattenPlugins = async (option) => {
+	const plugin = await option;
+	if (!(plugin !== void 0 && plugin !== null && plugin !== false)) return [];
+	if (Array.isArray(plugin)) return (await Promise.all(plugin.map(flattenPlugins))).flat();
+	return [plugin];
+};
+const getInstalledPreactVersion = (root) => {
+	const require = createRequire(path.join(root, "package.json"));
+	try {
+		const packageJsonPath = require.resolve("preact/package.json");
+		const packageJson = z.object({ version: z.string().optional() }).parse(require(packageJsonPath));
+		if (packageJson.version !== void 0) 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.");
+};
+/** Build the app client, private backend, migrations and deployment manifest. */
+const tailorkit = (options = {}) => {
+	let loaded;
+	let serverEntry;
+	let preactVersion;
+	let outputDirectory;
+	let resolvedOutDir;
+	let clientOutDir;
+	let watching = false;
+	let fileEntry;
+	let serverWatcher;
+	let resolved;
+	let customPlugins = [];
+	const instanceModules = /* @__PURE__ */ new Map();
+	const cleanup = async () => {
+		if (serverWatcher && "close" in serverWatcher) await serverWatcher.close();
+		await fileEntry?.close();
+	};
+	const writeBuildExtras = async () => {
+		const { views, instanceResolvers } = await readClientManifest(path.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).toSorted((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, watching, resolvedOutDir, activeModules, instanceResolvers, {
+			define: resolved.define,
+			mode: resolved.mode,
+			plugins: customPlugins,
+			resolve: resolved.resolve
+		});
+		const logoManifest = {};
+		for (const variant of ["light", "dark"]) {
+			const configuredPath = loaded.config.logos?.[variant];
+			if (!(configuredPath !== void 0 && configuredPath !== null && configuredPath !== "")) continue;
+			const extension = path.extname(configuredPath).toLowerCase().slice(1);
+			const contentType = (/* @__PURE__ */ new Map([
+				["png", "image/png"],
+				["svg", "image/svg+xml"],
+				["webp", "image/webp"]
+			])).get(extension);
+			if (!contentType) throw new Error(`The ${variant} logo must be an SVG, PNG, or WebP file.`);
+			const content = await readFile(path.resolve(loaded.root, configuredPath));
+			validateLogoAsset(content, contentType);
+			const filename = `logo-${variant}.${extension}`;
+			await writeFile(path.join(clientOutDir, filename), content);
+			logoManifest[variant] = `client/${filename}`;
+		}
+		await writeFile(path.join(clientOutDir, "views.json"), `${JSON.stringify(views)}\n`);
+		await writeFile(path.join(resolvedOutDir, "tailorkit-upload.json"), `${JSON.stringify(createTailorKitUploadManifest(logoManifest, Boolean(loaded.config.server), views), null, 2)}\n`, "utf-8");
+	};
+	const plugins = [
+		{
+			buildEnd: async (error) => {
+				if (error && !watching) await cleanup();
+			},
+			closeBundle: async () => {
+				if (!watching) await cleanup();
+			},
+			closeWatcher: cleanup,
+			config: async (config) => {
+				customPlugins = (await flattenPlugins(config.plugins ?? [])).filter((plugin) => !plugins.includes(plugin));
+				watching = Boolean(config.build?.watch);
+				outputDirectory = config.build?.outDir ?? ".tailorkit";
+				return {
+					build: {
+						emptyOutDir: true,
+						lib: {
+							entry: "tailorkit:client-entry",
+							fileName: "client",
+							formats: ["es"]
+						},
+						minify: "oxc",
+						outDir: path.join(outputDirectory, "client"),
+						rolldownOptions: { output: {
+							comments: {
+								annotation: false,
+								jsdoc: false,
+								legal: false
+							},
+							inlineDynamicImports: true,
+							minify: true,
+							minifyInternalExports: true
+						} }
+					},
+					define: {
+						"process.env.NODE_ENV": JSON.stringify(getBuildEnvironment().NODE_ENV ?? "production"),
+						...config.define
+					},
+					oxc: { jsx: { importSource: "preact" } }
+				};
+			},
+			configResolved: async (config) => {
+				const root = config.configFile !== void 0 && config.configFile !== null && config.configFile !== "" ? path.dirname(config.configFile) : config.root;
+				loaded = await loadTailorKitConfig(path.resolve(root, options.configPath ?? "tailorkit.config.ts"));
+				loaded.root = await realpath(root);
+				serverEntry = path.resolve(loaded.root, loaded.config.server?.entry ?? "src/server.ts");
+				preactVersion = getInstalledPreactVersion(loaded.root);
+				assertSupportedPreactVersion(preactVersion);
+				resolvedOutDir = path.resolve(loaded.root, outputDirectory);
+				validateServerBuildOutput(loaded, resolvedOutDir);
+				clientOutDir = path.join(resolvedOutDir, "client");
+				fileEntry = await createFileRouteEntry(loaded.root, resolvedOutDir, watching);
+				for (const build of [config.build, requireValue(config.environments.client).build]) {
+					build.outDir = clientOutDir;
+					if (build.lib !== false) build.lib.entry = fileEntry.entry;
+				}
+				resolved = config;
+			},
+			enforce: "pre",
+			name: "tailorkit",
+			writeBundle: async () => {
+				await writeBuildExtras();
+			}
+		},
+		fileRoutesPlugin(() => loaded.root),
+		instanceExtractionPlugin(() => loaded.root, () => Boolean(loaded.config.server), instanceModules),
+		{
+			enforce: "pre",
+			name: "tailorkit-browser-server-boundary",
+			async resolveId(id, importer) {
+				if (/^(?:@tailorkit\/app\/server$|tailorkit\/(?:server|app\/server)$|effect(?:\/|$))/u.test(id) || importer !== void 0 && importer !== null && importer !== "" && path.resolve(path.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 !== void 0 && importer !== null && importer !== "") {
+					if ((await this.resolve(id, importer, { skipSelf: true }))?.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;
+			}
+		},
+		{
+			enforce: "pre",
+			load: (id) => {
+				if (id === preactPackageJsonModuleId) {
+					const version = JSON.stringify(preactVersion);
+					return `export const version = ${version}; export default { version: ${version} };`;
+				}
+				return null;
+			},
+			name: "tailorkit-preact-package-json",
+			resolveId: (id) => id === preactPackageJson ? preactPackageJsonModuleId : null
+		}
+	];
+	for (const plugin of plugins) plugin.apply = "build";
+	return plugins;
+};
+//#endregion
+export { tailorkit };