@bgub/fig-tanstack-start 0.0.0-tegami-trusted-publish-setup → 0.1.0-alpha.2

package/dist/plugin/vite.js

@@ -0,0 +1,857 @@
+import { n as payloadStylesheetsSymbolKey } from "../payload-assets-eHfSAMbN.js";
+import { START_ENVIRONMENT_NAMES, tanStackStartVite } from "@tanstack/start-plugin-core/vite";
+import { figRefresh } from "@bgub/fig-vite";
+import { fileURLToPath } from "node:url";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import * as babel from "@babel/core";
+import presetTypescript from "@babel/preset-typescript";
+//#region src/plugin/module-ids.ts
+const payloadManifestDefinitionQuery = "fig-payload-manifest";
+const payloadModuleQuery = "fig-payload-module";
+const payloadReferenceQuery = "fig-payload-reference";
+function cleanModuleId(id) {
+	const query = id.indexOf("?");
+	return query === -1 ? id : id.slice(0, query);
+}
+function moduleQueryValue(id, name) {
+	const query = id.indexOf("?");
+	if (query === -1) return void 0;
+	const hash = id.indexOf("#", query);
+	return new URLSearchParams(id.slice(query + 1, hash === -1 ? void 0 : hash)).get(name) ?? void 0;
+}
+function hasModuleQuery(id, name) {
+	return moduleQueryValue(id, name) !== void 0;
+}
+function withModuleQuery(source, name, value) {
+	const hash = source.indexOf("#");
+	const suffix = hash === -1 ? "" : source.slice(hash);
+	const path = hash === -1 ? source : source.slice(0, hash);
+	return `${path}${path.includes("?") ? "&" : "?"}${name}=${encodeURIComponent(value)}${suffix}`;
+}
+function encodeOpaqueId(id) {
+	return Buffer$1.from(id).toString("base64url");
+}
+function decodeOpaqueId(id) {
+	return Buffer$1.from(id, "base64url").toString();
+}
+function toViteModulePath(root, moduleId) {
+	const clean = cleanModuleId(moduleId);
+	const path = isAbsolute(clean) ? relative(root, clean) : clean;
+	const normalized = normalizePath(path);
+	return isAbsolute(path) || normalized.startsWith("../") ? toViteFsPath(clean) : `/${normalized.replace(/^\/+/, "")}`;
+}
+function toViteFsPath(path) {
+	return `/@fs/${normalizePath(path).replace(/^\/+/, "")}`;
+}
+function normalizePath(path) {
+	return path.split(sep).join("/").replaceAll("\\", "/");
+}
+//#endregion
+//#region src/plugin/compatibility-profile.ts
+const tanStackCompatibilityProfile = {
+	id: "tanstack-start-core-1.171",
+	framework: "solid",
+	packages: {
+		figRouter: "@bgub/fig-tanstack-router",
+		figStart: "@bgub/fig-tanstack-start",
+		frameworkRouter: "@tanstack/solid-router",
+		frameworkStart: "@tanstack/solid-start",
+		startClient: "@tanstack/start-client-core",
+		startServer: "@tanstack/start-server-core"
+	},
+	versions: {
+		routerCore: "1.171.15",
+		startClientCore: "1.170.14",
+		startPluginCore: "1.171.22",
+		startServerCore: "1.169.17"
+	}
+};
+function createCompilerRpcModules(resolveDependency) {
+	const { frameworkStart, startClient, startServer } = tanStackCompatibilityProfile.packages;
+	return [
+		{
+			source: `${frameworkStart}/client-rpc`,
+			id: "\0fig-tanstack-start:client-rpc",
+			code: `export { createClientRpc } from "${startClient}/client-rpc";`
+		},
+		{
+			source: `${frameworkStart}/server-rpc`,
+			id: "\0fig-tanstack-start:server-rpc",
+			code: `export { createServerRpc } from ${JSON.stringify(resolveDependency(`${startServer}/createServerRpc`))};`
+		},
+		{
+			source: `${frameworkStart}/ssr-rpc`,
+			id: "\0fig-tanstack-start:ssr-rpc",
+			code: `export { createSsrRpc } from ${JSON.stringify(resolveDependency(`${startServer}/createSsrRpc`))};`
+		}
+	];
+}
+function createDefaultServerEntry() {
+	const { figStart } = tanStackCompatibilityProfile.packages;
+	return [
+		`import { createFigStartHandler } from ${JSON.stringify(`${figStart}/server`)};`,
+		"const fetch = createFigStartHandler();",
+		"export default { fetch };"
+	].join("\n");
+}
+function rewriteFrameworkImports(code) {
+	const { figStart, frameworkStart } = tanStackCompatibilityProfile.packages;
+	return code.replace(new RegExp(`\\b(from|import)\\s*(\\(\\s*)?(["'])${escapeRegExp(figStart)}\\3`, "g"), (_match, keyword, parenthesis, quote) => `${keyword}${parenthesis === void 0 ? " " : parenthesis}${quote}${frameworkStart}${quote}`);
+}
+function incompatibleRuntimeModules(moduleIds) {
+	const { frameworkRouter, frameworkStart } = tanStackCompatibilityProfile.packages;
+	const forbiddenPackages = [frameworkRouter, frameworkStart];
+	return [...moduleIds].filter((id) => {
+		const normalized = id.replaceAll("\\", "/");
+		return forbiddenPackages.some((packageName) => normalized.includes(`/node_modules/${packageName}/`));
+	});
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/plugin/compatibility-vite.ts
+const { figRouter: figRouterPackage, figStart: figTanStackStartPackage, frameworkRouter: tanstackRouterPackage, frameworkStart: tanstackStartPackage, startClient: tanstackStartClientPackage } = tanStackCompatibilityProfile.packages;
+const resolveDependency = (id) => fileURLToPath(import.meta.resolve(id));
+const tanstackStartClientModules = [
+	tanstackStartClientPackage,
+	`${tanstackStartClientPackage}/client`,
+	`${tanstackStartClientPackage}/client-rpc`
+];
+const tanstackStartClientAliases = tanstackStartClientModules.map((id) => ({
+	find: new RegExp(`^${id}$`),
+	replacement: resolveDependency(id)
+}));
+const optimizedClientModules = ["@tanstack/router-core/ssr/client"];
+const applicationEntryIds = /* @__PURE__ */ new Set(["#tanstack-router-entry", "#tanstack-start-entry"]);
+const storageContextPath = fileURLToPath(new URL("../storage-context.js", import.meta.url));
+const defaultEntryPaths = {
+	client: fileURLToPath(new URL("../default-entry/client.js", import.meta.url)),
+	server: fileURLToPath(new URL("../default-entry/server.js", import.meta.url)),
+	start: fileURLToPath(new URL("../default-entry/start.js", import.meta.url))
+};
+const compilerRpcModules = createCompilerRpcModules(resolveDependency);
+function startCompatibilityPlugin() {
+	const applicationEntryUrls = /* @__PURE__ */ new Map();
+	const optimizerApplicationEntries = {
+		name: "fig-tanstack-start:optimizer-application-entries",
+		resolveId(source) {
+			const id = applicationEntryUrls.get(source);
+			return id === void 0 ? null : {
+				external: true,
+				id
+			};
+		}
+	};
+	return {
+		name: "fig-tanstack-start:compatibility",
+		enforce: "pre",
+		config() {
+			return { resolve: {
+				alias: [
+					...tanstackStartClientAliases,
+					{
+						find: /^@tanstack\/start-storage-context$/,
+						replacement: storageContextPath
+					},
+					{
+						find: new RegExp(`^${tanstackRouterPackage}$`),
+						replacement: figRouterPackage
+					},
+					{
+						find: new RegExp(`^${tanstackStartPackage}$`),
+						replacement: figTanStackStartPackage
+					}
+				],
+				dedupe: [figTanStackStartPackage, figRouterPackage]
+			} };
+		},
+		configEnvironment(environmentName, environment) {
+			if (environmentName !== START_ENVIRONMENT_NAMES.client) return void 0;
+			const optimizerPlugins = environment.optimizeDeps?.rolldownOptions?.plugins;
+			return { optimizeDeps: {
+				include: [...environment.optimizeDeps?.include ?? [], ...optimizedClientModules],
+				exclude: [
+					...environment.optimizeDeps?.exclude ?? [],
+					...tanstackStartClientModules,
+					figTanStackStartPackage,
+					figRouterPackage
+				],
+				rolldownOptions: {
+					...environment.optimizeDeps?.rolldownOptions,
+					plugins: [...optimizerPlugins === void 0 ? [] : [optimizerPlugins], optimizerApplicationEntries]
+				}
+			} };
+		},
+		configResolved(config) {
+			for (const alias of config.resolve.alias) if (typeof alias.find === "string" && applicationEntryIds.has(alias.find)) applicationEntryUrls.set(alias.find, toViteFsPath(alias.replacement));
+		},
+		generateBundle(_options, bundle) {
+			if (this.environment.name !== START_ENVIRONMENT_NAMES.client) return;
+			const incompatible = incompatibleRuntimeModules(Object.values(bundle).flatMap((output) => output.type === "chunk" ? Object.entries(output.modules).flatMap(([id, module]) => module.renderedLength === 0 ? [] : [id]) : []));
+			if (incompatible.length === 0) return;
+			throw new Error(`${tanStackCompatibilityProfile.id} resolved compatibility-only Solid modules into the client runtime:\n${incompatible.join("\n")}`);
+		},
+		resolveId(source) {
+			return compilerRpcModules.find((module) => module.source === source)?.id;
+		},
+		load(id) {
+			const rpcModule = compilerRpcModules.find((module) => module.id === id);
+			if (rpcModule !== void 0) return rpcModule.code;
+			if (id === defaultEntryPaths.server) return createDefaultServerEntry();
+		},
+		transform(code) {
+			const rewritten = rewriteFrameworkImports(code);
+			return rewritten === code ? null : {
+				code: rewritten,
+				map: null
+			};
+		}
+	};
+}
+//#endregion
+//#region src/plugin/compiler-options.ts
+const payloadPackageId = "@bgub/fig-tanstack-start/payload";
+const serverPackageId = "@bgub/fig-tanstack-start/server";
+const sourceModuleExtensions = [
+	"js",
+	"jsx",
+	"ts",
+	"tsx",
+	"cjs",
+	"mjs",
+	"cts",
+	"mts"
+];
+const sourceModulePattern = new RegExp(`\\.(?:${sourceModuleExtensions.join("|")})$`);
+function babelOptions(filename) {
+	return {
+		babelrc: false,
+		configFile: false,
+		filename,
+		presets: [[presetTypescript, {
+			ignoreExtensions: true,
+			onlyRemoveTypeImports: true
+		}]],
+		parserOpts: { plugins: filename.endsWith("x") ? ["jsx"] : [] }
+	};
+}
+function isSourceModule(id) {
+	return sourceModulePattern.test(id);
+}
+function isComponentName(name) {
+	const first = name.codePointAt(0);
+	return first !== void 0 && first >= 65 && first <= 90;
+}
+function isImportedBinding(path, localName, importedName, source) {
+	const binding = path.scope.getBinding(localName);
+	if (!binding?.path.isImportSpecifier()) return false;
+	const imported = binding.path.node.imported;
+	return (imported.type === "Identifier" ? imported.name : imported.value) === importedName && binding.path.parentPath.isImportDeclaration() && binding.path.parentPath.node.source.value === source;
+}
+const resolvedPayloadManifestId = `\0virtual:fig-tanstack-start/payload-manifest`;
+function isomorphicReferenceId(root, moduleId, exportName) {
+	return `${toViteModulePath(root, moduleId)}#${exportName}`;
+}
+function payloadManifestDefinitionCode(references) {
+	return `export const references = {${references.map((reference) => {
+		const moduleId = withModuleQuery(reference.resolvedModuleId, payloadReferenceQuery, encodeOpaqueId(reference.referenceId));
+		return `${JSON.stringify(reference.referenceId)}: {
+      load: () => import(${JSON.stringify(moduleId)}).then((module) => module[${JSON.stringify(reference.importedName)}]),
+      stylesheets: ${JSON.stringify(reference.developmentStylesheetHrefs)},
+    }`;
+	}).join(",\n")}};`;
+}
+function payloadManifestRuntimeCode(clientStylesheets) {
+	const assets = JSON.stringify(Object.fromEntries(clientStylesheets));
+	return `import { stylesheet } from "@bgub/fig";
+import { createPayloadClientReferenceResolver } from "@bgub/fig/payload";
+
+const definitions = import.meta.glob([
+  "/**/*.{${sourceModuleExtensions.join(",")}}",
+  "!/**/*.d.ts",
+  "!/**/*.test.*",
+  "!/**/*.spec.*",
+  "!/**/__tests__/**",
+  "!/**/dist/**",
+  "!/**/node_modules/**",
+], {
+  eager: true,
+  import: "references",
+  query: "?${payloadManifestDefinitionQuery}",
+});
+const references = Object.assign({}, ...Object.values(definitions));
+const clientStylesheets = ${assets};
+
+export const resolveIsomorphicReference = createPayloadClientReferenceResolver(
+  (reference) => references[reference.id]?.load(),
+);
+
+export function compiledIsomorphicReferenceAssets({ id }) {
+  const hrefs = clientStylesheets[id] ?? references[id]?.stylesheets ?? [];
+  return hrefs.map((href) => stylesheet(href, { precedence: "isomorphic" }));
+}`;
+}
+function payloadReferenceIds(moduleIds) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const moduleId of moduleIds) {
+		const id = moduleQueryValue(moduleId, payloadReferenceQuery);
+		if (id !== void 0) ids.add(decodeOpaqueId(id));
+	}
+	return [...ids];
+}
+//#endregion
+//#region src/plugin/isomorphic-compiler.ts
+function isomorphicBoundaryAnalysisPlugin(imports) {
+	return () => ({
+		name: "fig-tanstack-start-isomorphic-boundary-analysis",
+		visitor: { Program(path) {
+			const seen = /* @__PURE__ */ new Set();
+			path.traverse({ JSXOpeningElement(elementPath) {
+				if (elementPath.node.name.type !== "JSXIdentifier" || !isIsomorphicBoundary(elementPath, elementPath.node.name.name)) return;
+				const component = isomorphicComponentAttribute(elementPath);
+				const imported = importedComponent(elementPath, component.node.name);
+				const key = `${imported.source}\0${imported.importedName}\0${component.node.name}`;
+				if (seen.has(key)) return;
+				seen.add(key);
+				imports.push({
+					...imported,
+					localName: component.node.name
+				});
+			} });
+		} }
+	});
+}
+function rewriteIsomorphicBoundaries(path, t, references) {
+	if (references.length === 0) return void 0;
+	const byLocalName = new Map(references.map((reference) => [reference.localName, reference]));
+	const createReference = path.scope.generateUidIdentifier("createIsomorphicReference");
+	let count = 0;
+	path.traverse({ JSXOpeningElement(elementPath) {
+		if (elementPath.node.name.type !== "JSXIdentifier" || !isIsomorphicBoundary(elementPath, elementPath.node.name.name)) return;
+		const component = isomorphicComponentAttribute(elementPath);
+		const reference = byLocalName.get(component.node.name);
+		if (reference === void 0) return;
+		component.replaceWith(t.callExpression(t.cloneNode(createReference), [t.stringLiteral(reference.referenceId)]));
+		count += 1;
+	} });
+	if (count === 0) return void 0;
+	path.scope.crawl();
+	for (const localName of byLocalName.keys()) {
+		const binding = path.scope.getBinding(localName);
+		if (binding?.referenced || !binding?.path.isImportSpecifier() && !binding?.path.isImportDefaultSpecifier()) continue;
+		const declaration = binding.path.parentPath;
+		binding.path.remove();
+		if (declaration.isImportDeclaration() && declaration.node.specifiers.length === 0) declaration.remove();
+	}
+	return createReference;
+}
+function isIsomorphicBoundary(path, localName) {
+	return isImportedBinding(path, localName, "Isomorphic", payloadPackageId);
+}
+function isomorphicComponentAttribute(path) {
+	const attribute = path.get("attributes").find((candidate) => candidate.isJSXAttribute() && candidate.node.name.type === "JSXIdentifier" && candidate.node.name.name === "component");
+	if (attribute === void 0 || !attribute.isJSXAttribute()) throw path.buildCodeFrameError("Isomorphic requires a component prop containing a statically imported component.");
+	const value = attribute.get("value");
+	if (!value.isJSXExpressionContainer()) throw attribute.buildCodeFrameError("Isomorphic component must be a statically imported component identifier.");
+	const expression = value.get("expression");
+	if (Array.isArray(expression) || !expression.isIdentifier()) throw value.buildCodeFrameError("Isomorphic component must be a statically imported component identifier.");
+	return expression;
+}
+function importedComponent(path, localName) {
+	const binding = path.scope.getBinding(localName);
+	if (binding === void 0 || !binding.path.isImportSpecifier() && !binding.path.isImportDefaultSpecifier() || !binding.path.parentPath.isImportDeclaration()) throw path.buildCodeFrameError("Isomorphic component must be a statically imported component identifier.");
+	return {
+		importedName: binding.path.isImportDefaultSpecifier() ? "default" : binding.path.node.imported.type === "Identifier" ? binding.path.node.imported.name : binding.path.node.imported.value,
+		source: binding.path.parentPath.node.source.value
+	};
+}
+//#endregion
+//#region src/plugin/payload-stylesheet-compiler.ts
+function stylesheetImportAnalysisPlugin(stylesheets) {
+	return () => ({
+		name: "fig-tanstack-start-stylesheet-import-analysis",
+		visitor: { ImportDeclaration(path) {
+			const source = path.node.source.value;
+			if (isStylesheetSpecifier(source)) stylesheets.push(source);
+		} }
+	});
+}
+function rewriteStylesheetImports(path, t) {
+	const hrefs = [];
+	for (const statement of path.get("body")) {
+		if (!statement.isImportDeclaration()) continue;
+		const source = statement.node.source.value;
+		if (!isStylesheetSpecifier(source)) continue;
+		const existingUrl = hasUrlQuery(source);
+		const defaultSpecifier = statement.node.specifiers.find((specifier) => t.isImportDefaultSpecifier(specifier));
+		if (existingUrl && defaultSpecifier !== void 0) {
+			hrefs.push(defaultSpecifier.local);
+			continue;
+		}
+		const local = path.scope.generateUidIdentifier("figPayloadStylesheet");
+		if (statement.node.specifiers.length === 0) {
+			statement.node.source = t.stringLiteral(withUrlQuery(source));
+			statement.node.specifiers.push(t.importDefaultSpecifier(local));
+		} else statement.insertAfter(t.importDeclaration([t.importDefaultSpecifier(local)], t.stringLiteral(withUrlQuery(source))));
+		hrefs.push(local);
+	}
+	return hrefs;
+}
+function collectComponentNames(path, t) {
+	const names = /* @__PURE__ */ new Set();
+	for (const statement of path.get("body")) {
+		const declaration = statement.isExportNamedDeclaration() || statement.isExportDefaultDeclaration() ? statement.get("declaration") : statement;
+		if (Array.isArray(declaration)) continue;
+		if (declaration.isFunctionDeclaration()) {
+			const name = declaration.node.id?.name;
+			if (name !== void 0 && isComponentName(name)) names.add(name);
+			continue;
+		}
+		if (!declaration.isVariableDeclaration()) continue;
+		for (const declarator of declaration.node.declarations) if (t.isIdentifier(declarator.id) && isComponentName(declarator.id.name) && (t.isArrowFunctionExpression(declarator.init) || t.isFunctionExpression(declarator.init))) names.add(declarator.id.name);
+	}
+	return [...names];
+}
+function isStylesheetSpecifier(source) {
+	const path = cleanModuleId(source);
+	return /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)$/.test(path);
+}
+function hasUrlQuery(source) {
+	return hasModuleQuery(source, "url");
+}
+function withUrlQuery(source) {
+	if (hasUrlQuery(source)) return source;
+	return `${source}${source.includes("?") ? "&" : "?"}url`;
+}
+//#endregion
+//#region src/plugin/payload-compiler.ts
+const payloadRuntimeId = "virtual:fig-tanstack-start/payload-runtime";
+const resolvedPayloadRuntimeId = `\0${payloadRuntimeId}`;
+const figRuntimePackageIds = [
+	"@bgub/fig",
+	"@bgub/fig-devtools",
+	"@bgub/fig-dom",
+	"@bgub/fig-reconciler",
+	"@bgub/fig-refresh",
+	"@bgub/fig-server",
+	"@bgub/fig-tanstack-router",
+	"@bgub/fig-tanstack-start",
+	"@bgub/fig-vite"
+];
+async function analyzeStylesheetImports(code, id) {
+	const clean = cleanModuleId(id);
+	if (!isSourceModule(clean)) return [];
+	const stylesheets = [];
+	await babel.transformAsync(code, {
+		...babelOptions(clean),
+		plugins: [stylesheetImportAnalysisPlugin(stylesheets)]
+	});
+	return stylesheets;
+}
+async function analyzeIsomorphicBoundaries(code, id) {
+	const clean = cleanModuleId(id);
+	if (!isSourceModule(clean) || !code.includes("Isomorphic")) return [];
+	const imports = [];
+	await babel.transformAsync(code, {
+		...babelOptions(clean),
+		plugins: [isomorphicBoundaryAnalysisPlugin(imports)]
+	});
+	return imports;
+}
+function mayBePayloadModule(code, id) {
+	return isSourceModule(cleanModuleId(id)) && (hasModuleQuery(id, "fig-payload-module") || code.includes("renderPayloadResponse"));
+}
+async function transformPayloadModule(code, id, isomorphicImports = []) {
+	if (!mayBePayloadModule(code, id)) return null;
+	const state = { changed: false };
+	const result = await babel.transformAsync(code, {
+		...babelOptions(cleanModuleId(id)),
+		sourceMaps: true,
+		plugins: [payloadBabelPlugin(isomorphicImports, hasModuleQuery(id, payloadModuleQuery), state)]
+	});
+	if (!state.changed || result?.code == null) return null;
+	return {
+		code: result.code,
+		map: result.map == null ? null : JSON.stringify(result.map)
+	};
+}
+function payloadRuntimeCode() {
+	return `import { clientReference } from "@bgub/fig";
+const stylesheetKey = Symbol.for(${JSON.stringify(payloadStylesheetsSymbolKey)});
+export function createIsomorphicReference(id) {
+  return clientReference({ id });
+}
+export function registerPayloadStylesheets(components, hrefs) {
+  for (const component of components) {
+    if (typeof component === "function") {
+      Object.defineProperty(component, stylesheetKey, { configurable: true, value: hrefs });
+    }
+  }
+}`;
+}
+function payloadBabelPlugin(isomorphicImports, compiledPayloadModule, state) {
+	return (api) => {
+		const t = api.types;
+		return {
+			name: "fig-tanstack-start-payload",
+			visitor: { Program: { exit(path) {
+				if (!compiledPayloadModule && !callsRenderPayloadResponse(path)) return;
+				const components = collectComponentNames(path, t);
+				const hrefs = components.length === 0 ? [] : rewriteStylesheetImports(path, t);
+				const createReference = rewriteIsomorphicBoundaries(path, t, isomorphicImports);
+				if (rewritePayloadComponentImports(path) > 0) state.changed = true;
+				const runtimeSpecifiers = [];
+				if (createReference !== void 0) runtimeSpecifiers.push(t.importSpecifier(createReference, t.identifier("createIsomorphicReference")));
+				let registerStylesheets;
+				if (hrefs.length > 0) {
+					registerStylesheets = path.scope.generateUidIdentifier("registerPayloadStylesheets");
+					runtimeSpecifiers.push(t.importSpecifier(registerStylesheets, t.identifier("registerPayloadStylesheets")));
+				}
+				if (runtimeSpecifiers.length === 0) return;
+				state.changed = true;
+				path.node.body.unshift(t.importDeclaration(runtimeSpecifiers, t.stringLiteral(payloadRuntimeId)));
+				if (registerStylesheets !== void 0) path.node.body.push(t.expressionStatement(t.callExpression(registerStylesheets, [t.arrayExpression(components.map((name) => t.identifier(name))), t.arrayExpression(hrefs)])));
+			} } }
+		};
+	};
+}
+function callsRenderPayloadResponse(path) {
+	let found = false;
+	path.traverse({ CallExpression(callPath) {
+		if (callPath.node.callee.type === "Identifier" && isImportedBinding(callPath, callPath.node.callee.name, "renderPayloadResponse", "@bgub/fig-tanstack-start/server")) {
+			found = true;
+			callPath.stop();
+		}
+	} });
+	return found;
+}
+function rewritePayloadComponentImports(path) {
+	const componentBindings = /* @__PURE__ */ new Set();
+	path.traverse({
+		JSXOpeningElement(elementPath) {
+			if (elementPath.node.name.type === "JSXNamespacedName") return;
+			const name = rootJsxIdentifier(elementPath.node.name);
+			if (name !== void 0) componentBindings.add(name);
+		},
+		CallExpression(callPath) {
+			if (callPath.node.callee.type !== "Identifier" || !isImportedBinding(callPath, callPath.node.callee.name, "createElement", "@bgub/fig")) return;
+			const [type] = callPath.node.arguments;
+			if (type?.type === "Identifier" && isComponentName(type.name)) componentBindings.add(type.name);
+		}
+	});
+	let count = 0;
+	for (const statement of path.get("body")) {
+		if (!statement.isImportDeclaration()) continue;
+		const source = statement.node.source.value;
+		if (statement.node.importKind === "type" || isStylesheetSpecifier(source) || isFigRuntimeSpecifier(source) || hasModuleQuery(source, "fig-payload-module") || !statement.node.specifiers.some((specifier) => !("importKind" in specifier && specifier.importKind === "type") && componentBindings.has(specifier.local.name))) continue;
+		statement.node.source.value = withModuleQuery(source, payloadModuleQuery, "1");
+		count += 1;
+	}
+	return count;
+}
+function isFigRuntimeSpecifier(source) {
+	return figRuntimePackageIds.some((packageId) => source === packageId || source.startsWith(`${packageId}/`));
+}
+function rootJsxIdentifier(name) {
+	let current = name;
+	while (current.type === "JSXMemberExpression") current = current.object;
+	return current.type === "JSXIdentifier" && isComponentName(current.name) ? current.name : void 0;
+}
+//#endregion
+//#region src/plugin/server-payload-compiler.ts
+const compiledServerPayloadMarkerKey = "fig.tanstack-start.compiled-server-payload";
+async function transformServerPayloadDefinitions(code, id) {
+	const clean = cleanModuleId(id);
+	if (!isSourceModule(clean) || !code.includes("serverPayload")) return null;
+	const state = { transformed: false };
+	const result = await babel.transformAsync(code, {
+		...babelOptions(clean),
+		sourceMaps: true,
+		plugins: [serverPayloadBabelPlugin(state)]
+	});
+	if (!state.transformed || result?.code == null) return null;
+	return {
+		code: result.code,
+		map: result.map == null ? null : JSON.stringify(result.map)
+	};
+}
+function serverPayloadBabelPlugin(state) {
+	return (api) => {
+		const t = api.types;
+		let createElement;
+		let createServerFn;
+		let renderPayloadResponse;
+		return {
+			name: "fig-tanstack-start-server-payload",
+			visitor: {
+				Program: {
+					enter(path) {
+						createElement = path.scope.generateUidIdentifier("createElement");
+						createServerFn = path.scope.generateUidIdentifier("createServerFn");
+						renderPayloadResponse = path.scope.generateUidIdentifier("renderPayloadResponse");
+					},
+					exit(path) {
+						if (!state.transformed) return;
+						path.node.body.unshift(t.importDeclaration([t.importSpecifier(createElement, t.identifier("createElement"))], t.stringLiteral("@bgub/fig")));
+						path.node.body.unshift(t.importDeclaration([t.importSpecifier(renderPayloadResponse, t.identifier("renderPayloadResponse"))], t.stringLiteral(serverPackageId)));
+						path.node.body.unshift(t.importDeclaration([t.importSpecifier(createServerFn, t.identifier("createServerFn"))], t.stringLiteral(tanStackCompatibilityProfile.packages.frameworkStart)));
+					}
+				},
+				CallExpression(path) {
+					if (path.node.callee.type !== "Identifier" || !isImportedBinding(path, path.node.callee.name, "serverPayload", "@bgub/fig-tanstack-start/payload")) return;
+					transformServerPayloadCall(path, t, createElement, createServerFn, renderPayloadResponse);
+					state.transformed = true;
+				}
+			}
+		};
+	};
+}
+function transformServerPayloadCall(path, t, createElement, createServerFn, renderPayloadResponse) {
+	const [render, ...extra] = path.node.arguments;
+	if (render === void 0 || render.type === "SpreadElement" || render.type === "ArgumentPlaceholder" || extra.length > 0) throw path.buildCodeFrameError("serverPayload requires exactly one server component or render callback.");
+	if (!isRenderExpression(render)) throw path.buildCodeFrameError("serverPayload requires a component reference or inline render callback.");
+	const statement = path.getStatementParent();
+	if (path.getFunctionParent() !== null || statement === null || !statement.parentPath.isProgram()) throw path.buildCodeFrameError("serverPayload must be declared in a top-level statement.");
+	const declarator = path.findParent((candidate) => candidate.isVariableDeclarator());
+	const requestName = declarator?.isVariableDeclarator() && declarator.node.id.type === "Identifier" ? `${declarator.node.id.name}Request` : "payloadRequest";
+	const request = statement.scope.generateUidIdentifier(requestName);
+	const data = statement.scope.generateUidIdentifier("data");
+	const input = statement.scope.generateUidIdentifier("input");
+	const signal = statement.scope.generateUidIdentifier("signal");
+	const serverFn = t.callExpression(t.memberExpression(t.callExpression(createServerFn, []), t.identifier("handler")), [t.arrowFunctionExpression([t.objectPattern([t.objectProperty(t.identifier("data"), data, false, false)])], t.callExpression(renderPayloadResponse, [t.callExpression(createElement, [render, data])]))]);
+	statement.insertBefore(t.variableDeclaration("const", [t.variableDeclarator(request, serverFn)]));
+	const proxy = t.arrowFunctionExpression([input, t.objectPattern([t.objectProperty(t.identifier("signal"), signal, false, false)])], t.callExpression(request, [t.objectExpression([t.objectProperty(t.identifier("data"), input, false, false), t.objectProperty(t.identifier("signal"), signal, false, false)])]));
+	path.node.arguments = [t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("assign")), [proxy, t.objectExpression([t.objectProperty(t.callExpression(t.memberExpression(t.identifier("Symbol"), t.identifier("for")), [t.stringLiteral(compiledServerPayloadMarkerKey)]), t.booleanLiteral(true), true)])])];
+}
+function isRenderExpression(value) {
+	return value.type === "ArrowFunctionExpression" || value.type === "FunctionExpression" && !value.generator || value.type === "Identifier" || value.type === "MemberExpression";
+}
+//#endregion
+//#region src/plugin/public-assets.ts
+async function writePublicAsset(path, source) {
+	const bytes = Buffer.from(source);
+	let existing;
+	try {
+		existing = await readFile(path);
+	} catch (error) {
+		if (!isMissingFile(error)) throw error;
+	}
+	if (existing !== void 0) {
+		if (existing.equals(bytes)) return;
+		throw new Error(`TanStack Start server asset ${JSON.stringify(path)} conflicts with a different client asset at the same public path. Use content-hashed or separately namespaced asset file names.`);
+	}
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, bytes);
+}
+function isMissingFile(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+//#endregion
+//#region src/plugin/payload-vite.ts
+const payloadManifestDefinitionPrefix = "\0fig-tanstack-start:payload-manifest-definition:";
+function serverPayloadPlugin() {
+	return {
+		name: "fig-tanstack-start:server-payload",
+		enforce: "pre",
+		transform: transformServerPayloadDefinitions
+	};
+}
+function payloadPlugin() {
+	let root = process.cwd();
+	let base = "/";
+	let clientOutDir;
+	let serverAssetsPrefix = "assets/";
+	const clientStylesheets = /* @__PURE__ */ new Map();
+	const definitionInputs = /* @__PURE__ */ new Map();
+	return {
+		name: "fig-tanstack-start:payload",
+		enforce: "pre",
+		configEnvironment(environmentName) {
+			if (environmentName === START_ENVIRONMENT_NAMES.server) return { build: { emitAssets: true } };
+		},
+		configResolved(config) {
+			root = config.root;
+			base = config.base;
+			const outDir = config.environments[START_ENVIRONMENT_NAMES.client]?.build.outDir;
+			if (outDir !== void 0) clientOutDir = resolve(config.root, outDir);
+			const assetsDir = config.environments[START_ENVIRONMENT_NAMES.server]?.build.assetsDir;
+			if (assetsDir !== void 0) {
+				const normalized = assetsDir.replace(/\/+$/, "");
+				serverAssetsPrefix = normalized === "" ? "" : `${normalized}/`;
+			}
+		},
+		async writeBundle(_options, bundle) {
+			if (this.environment.name !== START_ENVIRONMENT_NAMES.server || clientOutDir === void 0) return;
+			const publicOutDir = clientOutDir;
+			await Promise.all(Object.values(bundle).map(async (output) => {
+				if (output.type !== "asset" || !output.fileName.startsWith(serverAssetsPrefix) || output.fileName.endsWith(".map")) return;
+				await writePublicAsset(resolve(publicOutDir, output.fileName), output.source);
+			}));
+		},
+		generateBundle(_options, bundle) {
+			if (this.environment.name !== START_ENVIRONMENT_NAMES.client) return;
+			collectClientStylesheets(bundle, clientStylesheets, base);
+		},
+		async resolveId(source, importer) {
+			if (source === "virtual:fig-tanstack-start/payload-runtime") return resolvedPayloadRuntimeId;
+			if (source === "virtual:fig-tanstack-start/payload-manifest") return resolvedPayloadManifestId;
+			if (hasModuleQuery(source, "fig-payload-module")) {
+				const resolved = await this.resolve(cleanModuleId(source), importer, { skipSelf: true });
+				return resolved === null ? null : withModuleQuery(cleanModuleId(resolved.id), payloadModuleQuery, "1");
+			}
+			if (!hasModuleQuery(source, "fig-payload-manifest")) return;
+			const resolved = await this.resolve(cleanModuleId(source), importer, { skipSelf: true });
+			if (resolved === null) return null;
+			return definitionModuleId(cleanModuleId(resolved.id));
+		},
+		async load(id) {
+			if (id === resolvedPayloadRuntimeId) return payloadRuntimeCode();
+			if (id === resolvedPayloadManifestId) return payloadManifestRuntimeCode(clientStylesheets);
+			if (!id.startsWith(payloadManifestDefinitionPrefix)) return void 0;
+			const sourceId = decodeOpaqueId(id.slice(48));
+			const code = rewriteFrameworkImports(await readFile(sourceId, "utf8"));
+			const stylesheetSources = /* @__PURE__ */ new Map();
+			const references = await collectPayloadReferences(sourceId, code, (source, importer) => this.resolve(source, importer, { skipSelf: true }), root, stylesheetSources);
+			if (references.length > 0) {
+				this.addWatchFile(sourceId);
+				definitionInputs.set(sourceId, {
+					boundaries: boundaryFingerprint(references),
+					stylesheetSources
+				});
+			} else definitionInputs.delete(sourceId);
+			return payloadManifestDefinitionCode(references);
+		},
+		async hotUpdate({ file, modules, read }) {
+			const { moduleGraph } = this.environment;
+			const invalidated = /* @__PURE__ */ new Set();
+			let content;
+			const readContent = async () => content ??= await read();
+			const definition = moduleGraph.getModuleById(definitionModuleId(file));
+			if (definition !== void 0) {
+				let changed;
+				try {
+					const boundaries = boundaryFingerprint(await analyzeIsomorphicBoundaries(rewriteFrameworkImports(await readContent()), file));
+					changed = (definitionInputs.get(file)?.boundaries ?? emptyBoundaryFingerprint) !== boundaries;
+				} catch {
+					changed = true;
+				}
+				if (changed) invalidated.add(definition);
+			}
+			const dependents = [...definitionInputs].filter(([, inputs]) => inputs.stylesheetSources.has(file));
+			if (dependents.length > 0) {
+				let sources;
+				try {
+					sources = stylesheetSourceFingerprint(await analyzeStylesheetImports(await readContent(), file));
+				} catch {
+					sources = void 0;
+				}
+				for (const [sourceId, inputs] of dependents) {
+					if (inputs.stylesheetSources.get(file) === sources) continue;
+					const dependent = moduleGraph.getModuleById(definitionModuleId(sourceId));
+					if (dependent !== void 0) invalidated.add(dependent);
+				}
+			}
+			if (invalidated.size === 0) return void 0;
+			return [...modules, ...invalidated];
+		},
+		async transform(code, id) {
+			if (this.environment.name !== START_ENVIRONMENT_NAMES.server || !mayBePayloadModule(code, id)) return null;
+			return transformPayloadModule(code, id, await collectPayloadReferences(id, code, (source, importer) => this.resolve(source, importer, { skipSelf: true }), root));
+		}
+	};
+}
+function definitionModuleId(sourceId) {
+	return `${payloadManifestDefinitionPrefix}${encodeOpaqueId(sourceId)}`;
+}
+function boundaryFingerprint(imports) {
+	return JSON.stringify(imports.map(({ importedName, localName, source }) => [
+		source,
+		importedName,
+		localName
+	]));
+}
+const emptyBoundaryFingerprint = boundaryFingerprint([]);
+function stylesheetSourceFingerprint(sources) {
+	return JSON.stringify(sources);
+}
+async function collectPayloadReferences(id, code, resolveModule, root, stylesheetSources) {
+	const importerId = cleanModuleId(id);
+	const imports = await analyzeIsomorphicBoundaries(code, id);
+	return Promise.all(imports.map(async (imported) => {
+		const resolved = await resolveModule(imported.source, importerId);
+		if (resolved === null) throw new Error(`Cannot resolve Isomorphic component import ${JSON.stringify(imported.source)} from ${importerId}.`);
+		const moduleId = cleanModuleId(resolved.id);
+		const referenceId = isomorphicReferenceId(root, moduleId, imported.importedName);
+		let hrefs = [];
+		if (stylesheetSources !== void 0) {
+			const stylesheets = await moduleStylesheets(moduleId, root, resolveModule);
+			hrefs = stylesheets.hrefs;
+			stylesheetSources.set(moduleId, stylesheetSourceFingerprint(stylesheets.sources));
+		}
+		return {
+			...imported,
+			referenceId,
+			resolvedModuleId: moduleId,
+			developmentStylesheetHrefs: hrefs
+		};
+	}));
+}
+async function moduleStylesheets(moduleId, root, resolveModule) {
+	if (!isAbsolute(moduleId)) return {
+		hrefs: [],
+		sources: []
+	};
+	let code;
+	try {
+		code = await readFile(moduleId, "utf8");
+	} catch {
+		return {
+			hrefs: [],
+			sources: []
+		};
+	}
+	const sources = await analyzeStylesheetImports(code, moduleId);
+	return {
+		hrefs: (await Promise.all(sources.map(async (source) => {
+			const resolved = await resolveModule(source, moduleId);
+			return resolved === null ? void 0 : toViteModulePath(root, cleanModuleId(resolved.id));
+		}))).filter((href) => href !== void 0),
+		sources
+	};
+}
+function collectClientStylesheets(bundle, clientStylesheets, base) {
+	clientStylesheets.clear();
+	for (const output of Object.values(bundle)) {
+		if (output.type !== "chunk") continue;
+		const referenceIds = payloadReferenceIds(Object.keys(output.modules));
+		for (const referenceId of referenceIds) {
+			const stylesheets = new Set(clientStylesheets.get(referenceId));
+			for (const file of output.viteMetadata?.importedCss ?? []) stylesheets.add(`${base.replace(/\/$/, "")}/${file}`);
+			clientStylesheets.set(referenceId, [...stylesheets]);
+		}
+	}
+}
+//#endregion
+//#region src/plugin/vite.ts
+function tanstackStart(options) {
+	return [
+		startCompatibilityPlugin(),
+		serverPayloadPlugin(),
+		payloadPlugin(),
+		tanStackStartVite({
+			defaultEntryPaths,
+			framework: tanStackCompatibilityProfile.framework,
+			providerEnvironmentName: START_ENVIRONMENT_NAMES.server,
+			ssrIsProvider: true,
+			ssrResolverStrategy: { type: "default" }
+		}, options),
+		figRefresh()
+	];
+}
+//#endregion
+export { tanstackStart };
+
+//# sourceMappingURL=vite.js.map