vorzelajs 0.0.1

package/dist/vite/routes-plugin.js

@@ -0,0 +1,345 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const ROUTES_DIR = path.join('src', 'routes');
+const OUTPUT_FILE = path.join('src', 'routeTree.gen.ts');
+const OUTPUT_HYDRATION_FILE = path.join('src', 'routeHydration.gen.ts');
+const ROUTE_FILE_PATTERN = /\.(ts|tsx)$/u;
+const SERVER_ONLY_ROUTE_FILE_PATTERN = /\.server\.(ts|tsx)$/u;
+const SERVER_ONLY_DIR_PATTERN = /[\\/]\.server[\\/]/u;
+const SERVER_ONLY_SPECIFIER_PATTERN = /(?:^|[\\/])\.server(?:[\\/]|$)|\.server(?:$|\.)/u;
+const CLIENT_EVENT_HANDLER_PATTERN = /\bon[A-Z][A-Za-z0-9]*\s*=/u;
+const CLIENT_ROUTER_HOOK_PATTERN = /\b(useNavigate|useSetSearch|Route\.useSetSearch)\b/u;
+const CLIENT_SOLID_HOOK_PATTERN = /\b(createSignal|createEffect|createRenderEffect|createResource|onMount|onCleanup)\b/u;
+const CLIENT_BROWSER_GLOBAL_PATTERN = /\b(window|document|navigator|localStorage|sessionStorage)\s*\./u;
+const CLIENT_BROWSER_FUNCTION_PATTERN = /\b(requestAnimationFrame|matchMedia)\s*\(/u;
+const SOURCE_FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+const IMPORT_EXPORT_PATTERN = /\b(?:import|export)\s+(?!type\b)[\w\s{},*]+?\s+from\s+['"]([^'"]+)['"]/gu;
+const SIDE_EFFECT_IMPORT_PATTERN = /\bimport\s+['"]([^'"]+)['"]/gu;
+const DYNAMIC_IMPORT_PATTERN = /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/gu;
+function toPosix(value) {
+    return value.split(path.sep).join('/');
+}
+function isPathlessSegment(segment) {
+    return segment.startsWith('_') && segment !== '__root';
+}
+function isServerOnlyRouteFile(filePath) {
+    return SERVER_ONLY_ROUTE_FILE_PATTERN.test(filePath) || SERVER_ONLY_DIR_PATTERN.test(filePath);
+}
+function isServerOnlyModuleSpecifier(specifier) {
+    return SERVER_ONLY_SPECIFIER_PATTERN.test(specifier);
+}
+async function walkFiles(dirPath) {
+    try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        const nestedFiles = await Promise.all(entries.map(async (entry) => {
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                return walkFiles(fullPath);
+            }
+            return entry.isFile() ? [fullPath] : [];
+        }));
+        return nestedFiles.flat();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+function getRouteInfo(filePath, routesDir) {
+    const relativePath = toPosix(path.relative(routesDir, filePath));
+    const withoutExtension = relativePath.replace(ROUTE_FILE_PATTERN, '');
+    const importPath = `./routes/${withoutExtension}`;
+    if (withoutExtension === '__root') {
+        return {
+            filePath,
+            fullPath: '/',
+            id: '__root__',
+            importPath,
+            matchPath: null,
+            parentId: null,
+            sourcePath: withoutExtension,
+            to: '/',
+            isPathlessFile: false,
+        };
+    }
+    const segments = withoutExtension.split('/');
+    const isIndex = segments[segments.length - 1] === 'index';
+    const fileSegment = segments[segments.length - 1];
+    const directorySegments = segments.slice(0, -1);
+    const publicDirectorySegments = directorySegments.filter((segment) => !isPathlessSegment(segment));
+    const isPathlessFile = isPathlessSegment(fileSegment);
+    const publicSegments = isIndex || isPathlessFile
+        ? publicDirectorySegments
+        : [...publicDirectorySegments, fileSegment];
+    const fullPath = publicSegments.length > 0 ? `/${publicSegments.join('/')}` : '/';
+    const id = withoutExtension === 'index'
+        ? '/'
+        : isIndex
+            ? `/${directorySegments.join('/')}/`
+            : `/${withoutExtension}`;
+    return {
+        filePath,
+        fullPath,
+        id,
+        importPath,
+        matchPath: isPathlessFile ? null : fullPath,
+        parentId: '__root__',
+        sourcePath: withoutExtension,
+        to: fullPath,
+        isPathlessFile,
+    };
+}
+function findParentRouteId(route, routesBySourcePath) {
+    if (route.id === '__root__') {
+        return null;
+    }
+    const sourceSegments = route.sourcePath.split('/');
+    const directorySegments = sourceSegments.slice(0, -1);
+    for (let depth = directorySegments.length; depth > 0; depth -= 1) {
+        const candidateSourcePath = directorySegments.slice(0, depth).join('/');
+        const candidateRoute = routesBySourcePath.get(candidateSourcePath);
+        if (candidateRoute?.isPathlessFile) {
+            return candidateRoute.id;
+        }
+    }
+    return '__root__';
+}
+function assertNoDuplicateMatchPaths(routes) {
+    const seen = new Map();
+    routes.forEach((route) => {
+        if (!route.matchPath) {
+            return;
+        }
+        const existing = seen.get(route.matchPath);
+        if (existing) {
+            throw new Error(`Duplicate routable path '${route.matchPath}' detected for '${existing}' and '${route.sourcePath}'`);
+        }
+        seen.set(route.matchPath, route.sourcePath);
+    });
+}
+function createGeneratedFile(routes) {
+    const sortedRoutes = [...routes].sort((left, right) => {
+        if (left.id === '__root__')
+            return -1;
+        if (right.id === '__root__')
+            return 1;
+        return left.id.localeCompare(right.id);
+    });
+    const routesById = sortedRoutes
+        .map((route) => `  '${route.id}': typeof import('${route.importPath}')['Route']`)
+        .join('\n');
+    const routesByFullPath = sortedRoutes
+        .filter((route) => route.id !== '__root__' && route.matchPath !== null)
+        .map((route) => `  '${route.fullPath}': typeof import('${route.importPath}')['Route']`)
+        .join('\n');
+    const routesByTo = sortedRoutes
+        .filter((route) => route.id !== '__root__' && route.matchPath !== null)
+        .map((route) => `  '${route.to}': typeof import('${route.importPath}')['Route']`)
+        .join('\n');
+    const manifestEntries = sortedRoutes.map((route) => `  {
+    id: '${route.id}',
+    fullPath: '${route.fullPath}',
+    matchPath: ${route.matchPath ? `'${route.matchPath}'` : 'null'},
+    to: '${route.to}',
+    parentId: ${route.parentId ? `'${route.parentId}'` : 'null'},
+    importPath: '${route.importPath}',
+    loadRoute: () => import('${route.importPath}'),
+  }`).join(',\n');
+    return `/* eslint-disable */
+
+// @ts-nocheck
+
+// This file was automatically generated by VorzelaJs.
+// Do not edit this file manually.
+
+import type { GeneratedRouteRecord } from 'vorzelajs'
+
+export const routeManifest = [
+${manifestEntries}
+] as const satisfies readonly GeneratedRouteRecord[]
+
+export interface FileRoutesById {
+${routesById}
+}
+
+export interface FileRoutesByFullPath {
+${routesByFullPath}
+}
+
+export interface FileRoutesByTo {
+${routesByTo}
+}
+
+export type RouteId = keyof FileRoutesById
+export type RouteFullPath = keyof FileRoutesByFullPath
+export type RouteTo = keyof FileRoutesByTo
+`;
+}
+function detectRouteHydration(source) {
+    return CLIENT_EVENT_HANDLER_PATTERN.test(source)
+        || CLIENT_ROUTER_HOOK_PATTERN.test(source)
+        || CLIENT_SOLID_HOOK_PATTERN.test(source)
+        || CLIENT_BROWSER_GLOBAL_PATTERN.test(source)
+        || CLIENT_BROWSER_FUNCTION_PATTERN.test(source)
+        ? 'client'
+        : 'static';
+}
+function isLocalModuleSpecifier(specifier) {
+    return specifier.startsWith('./') || specifier.startsWith('../');
+}
+function extractLocalImportSpecifiers(source) {
+    const specifiers = new Set();
+    for (const pattern of [IMPORT_EXPORT_PATTERN, SIDE_EFFECT_IMPORT_PATTERN, DYNAMIC_IMPORT_PATTERN]) {
+        pattern.lastIndex = 0;
+        for (const match of source.matchAll(pattern)) {
+            const specifier = match[1];
+            if (specifier && isLocalModuleSpecifier(specifier) && !isServerOnlyModuleSpecifier(specifier)) {
+                specifiers.add(specifier);
+            }
+        }
+    }
+    return [...specifiers];
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveLocalModulePath(specifier, importerPath) {
+    const basePath = path.resolve(path.dirname(importerPath), specifier);
+    const candidates = path.extname(basePath)
+        ? [basePath]
+        : [
+            ...SOURCE_FILE_EXTENSIONS.map((extension) => `${basePath}${extension}`),
+            ...SOURCE_FILE_EXTENSIONS.map((extension) => path.join(basePath, `index${extension}`)),
+        ];
+    for (const candidate of candidates) {
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function detectRouteHydrationFromFile(filePath, cache) {
+    const resolvedPath = path.resolve(filePath);
+    const cached = cache.get(resolvedPath);
+    if (cached) {
+        return cached;
+    }
+    const pending = (async () => {
+        const source = await fs.readFile(resolvedPath, 'utf-8');
+        if (detectRouteHydration(source) === 'client') {
+            return 'client';
+        }
+        for (const specifier of extractLocalImportSpecifiers(source)) {
+            const dependencyPath = await resolveLocalModulePath(specifier, resolvedPath);
+            if (!dependencyPath) {
+                continue;
+            }
+            if (await detectRouteHydrationFromFile(dependencyPath, cache) === 'client') {
+                return 'client';
+            }
+        }
+        return 'static';
+    })();
+    cache.set(resolvedPath, pending);
+    return pending;
+}
+async function createGeneratedHydrationFile(routes) {
+    const sortedRoutes = [...routes].sort((left, right) => {
+        if (left.id === '__root__')
+            return -1;
+        if (right.id === '__root__')
+            return 1;
+        return left.id.localeCompare(right.id);
+    });
+    const hydrationCache = new Map();
+    const hydrationEntries = await Promise.all(sortedRoutes.map(async (route) => {
+        const detected = await detectRouteHydrationFromFile(route.filePath, hydrationCache);
+        return `  '${route.id}': { detected: '${detected}' }`;
+    }));
+    return `/* eslint-disable */
+
+// This file was automatically generated by VorzelaJs.
+// Do not edit this file manually.
+
+import type { GeneratedRouteHydrationRecord } from 'vorzelajs'
+
+export const routeHydrationManifest = {
+${hydrationEntries.join(',\n')}
+} as const satisfies Readonly<Record<string, GeneratedRouteHydrationRecord>>
+`;
+}
+async function writeIfChanged(filePath, content) {
+    const current = await fs.readFile(filePath, 'utf-8').catch(() => null);
+    if (current !== content) {
+        await fs.writeFile(filePath, content, 'utf-8');
+    }
+}
+export async function generateRoutes(projectRoot = process.cwd()) {
+    const routesDir = path.resolve(projectRoot, ROUTES_DIR);
+    const outputPath = path.resolve(projectRoot, OUTPUT_FILE);
+    const hydrationOutputPath = path.resolve(projectRoot, OUTPUT_HYDRATION_FILE);
+    const routeFiles = (await walkFiles(routesDir))
+        .filter((filePath) => ROUTE_FILE_PATTERN.test(filePath))
+        .filter((filePath) => !isServerOnlyRouteFile(filePath))
+        .filter((filePath) => !filePath.endsWith('.d.ts'));
+    const routes = routeFiles.map((filePath) => getRouteInfo(filePath, routesDir));
+    if (!routes.some((route) => route.id === '__root__')) {
+        throw new Error(`Missing root route file at ${path.join(routesDir, '__root.tsx')}`);
+    }
+    const routesBySourcePath = new Map(routes.map((route) => [route.sourcePath, route]));
+    const routesWithParents = routes.map((route) => ({
+        ...route,
+        parentId: findParentRouteId(route, routesBySourcePath),
+    }));
+    assertNoDuplicateMatchPaths(routesWithParents);
+    await Promise.all([
+        writeIfChanged(outputPath, createGeneratedFile(routesWithParents)),
+        writeIfChanged(hydrationOutputPath, await createGeneratedHydrationFile(routesWithParents)),
+    ]);
+}
+export function vorzelaRoutesPlugin() {
+    let projectRoot = process.cwd();
+    return {
+        name: 'vorzelajs-routes',
+        enforce: 'pre',
+        configResolved(config) {
+            projectRoot = config.root;
+        },
+        async buildStart() {
+            await generateRoutes(projectRoot);
+        },
+        configureServer(server) {
+            const sourceRoot = path.resolve(projectRoot, 'src');
+            const generatedRouteTreePath = path.resolve(projectRoot, OUTPUT_FILE);
+            const generatedHydrationPath = path.resolve(projectRoot, OUTPUT_HYDRATION_FILE);
+            const handleRouteChange = async (filePath) => {
+                const absolutePath = path.resolve(filePath);
+                if (absolutePath === generatedRouteTreePath
+                    || absolutePath === generatedHydrationPath
+                    || !absolutePath.startsWith(sourceRoot)
+                    || !ROUTE_FILE_PATTERN.test(absolutePath)
+                    || isServerOnlyRouteFile(absolutePath)) {
+                    return;
+                }
+                try {
+                    await generateRoutes(projectRoot);
+                    server.ws.send({ type: 'full-reload' });
+                }
+                catch (error) {
+                    server.config.logger.error(`[vorzelajs-routes] ${error.message}`);
+                }
+            };
+            server.watcher.on('add', handleRouteChange);
+            server.watcher.on('change', handleRouteChange);
+            server.watcher.on('unlink', handleRouteChange);
+        },
+    };
+}

package/dist/vite/server-only.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export declare function vorzelaServerOnlyPlugin(): Plugin;
+//# sourceMappingURL=server-only.d.ts.map

package/dist/vite/server-only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-only.d.ts","sourceRoot":"","sources":["../../src/vite/server-only.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAsblC,wBAAgB,uBAAuB,IAAI,MAAM,CA2BhD"}

package/dist/vite/server-only.js

@@ -0,0 +1,342 @@
+import path from 'node:path';
+import ts from 'typescript';
+const ROUTE_FILE_PATTERN = /src[\\/]routes[\\/].*\.(ts|tsx)$/u;
+const SERVER_ONLY_MODULE_PATTERN = /(?:^|[\\/])\.server(?:[\\/]|$)|\.server(?:$|\.)/u;
+const ROUTE_SERVER_PROPERTY_NAMES = new Set(['loader', 'beforeLoad', 'validateSearch']);
+function stripQuerySuffix(value) {
+    const queryIndex = value.indexOf('?');
+    return queryIndex === -1 ? value : value.slice(0, queryIndex);
+}
+function isRouteFileId(id) {
+    return ROUTE_FILE_PATTERN.test(stripQuerySuffix(id));
+}
+function isServerOnlyModuleSpecifier(specifier) {
+    return SERVER_ONLY_MODULE_PATTERN.test(specifier);
+}
+function formatRelativeId(id, root) {
+    return path.relative(root, stripQuerySuffix(id)) || stripQuerySuffix(id);
+}
+function getObjectLiteralElementName(property) {
+    if (!('name' in property)) {
+        return null;
+    }
+    return getPropertyNameText(property.name);
+}
+function getPropertyNameText(name) {
+    if (!name) {
+        return null;
+    }
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return null;
+}
+function getBindingNames(name, names = []) {
+    if (ts.isIdentifier(name)) {
+        names.push(name.text);
+        return names;
+    }
+    for (const element of name.elements) {
+        if (!ts.isOmittedExpression(element)) {
+            getBindingNames(element.name, names);
+        }
+    }
+    return names;
+}
+function getTopLevelStatementBindingNames(statement) {
+    if (ts.isFunctionDeclaration(statement) && statement.name) {
+        return [statement.name.text];
+    }
+    if (ts.isVariableStatement(statement)) {
+        return statement.declarationList.declarations.flatMap((declaration) => getBindingNames(declaration.name));
+    }
+    return [];
+}
+function isNodeWithinRanges(node, sourceFile, ranges) {
+    const start = node.getStart(sourceFile);
+    return ranges.some((range) => start >= range.start && node.end <= range.end);
+}
+function isIdentifierReference(node) {
+    const parent = node.parent;
+    if ((ts.isPropertyAssignment(parent) && parent.name === node && parent.initializer !== node)
+        || (ts.isShorthandPropertyAssignment(parent) && parent.name === node && parent.objectAssignmentInitializer !== undefined)
+        || (ts.isMethodDeclaration(parent) && parent.name === node)
+        || (ts.isPropertyDeclaration(parent) && parent.name === node)
+        || (ts.isPropertySignature(parent) && parent.name === node)
+        || (ts.isPropertyAccessExpression(parent) && parent.name === node)
+        || (ts.isQualifiedName(parent) && parent.right === node)
+        || (ts.isImportClause(parent) && parent.name === node)
+        || (ts.isImportSpecifier(parent) && (parent.name === node || parent.propertyName === node))
+        || (ts.isNamespaceImport(parent) && parent.name === node)
+        || (ts.isBindingElement(parent) && (parent.name === node || parent.propertyName === node))
+        || (ts.isVariableDeclaration(parent) && parent.name === node)
+        || (ts.isFunctionDeclaration(parent) && parent.name === node)
+        || (ts.isParameter(parent) && parent.name === node)
+        || ts.isTypeReferenceNode(parent)
+        || ts.isExpressionWithTypeArguments(parent)
+        || ts.isImportTypeNode(parent)
+        || ts.isTypeQueryNode(parent)) {
+        return false;
+    }
+    return true;
+}
+function isRouteOptionsObject(node) {
+    const propertyNames = new Set(node.properties
+        .map((property) => getObjectLiteralElementName(property))
+        .filter((name) => name !== null));
+    return propertyNames.has('component');
+}
+function collectRouteServerOnlyContext(sourceFile) {
+    const ranges = [];
+    const topLevelBindingNames = new Set();
+    const visit = (node) => {
+        if (ts.isObjectLiteralExpression(node) && isRouteOptionsObject(node)) {
+            for (const property of node.properties) {
+                const name = getObjectLiteralElementName(property);
+                if (!name || !ROUTE_SERVER_PROPERTY_NAMES.has(name)) {
+                    continue;
+                }
+                ranges.push({
+                    end: property.end,
+                    start: property.getStart(sourceFile),
+                });
+                if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.initializer)) {
+                    topLevelBindingNames.add(property.initializer.text);
+                }
+                if (ts.isShorthandPropertyAssignment(property)) {
+                    topLevelBindingNames.add(property.name.text);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    for (const statement of sourceFile.statements) {
+        if (getTopLevelStatementBindingNames(statement).some((name) => topLevelBindingNames.has(name))) {
+            ranges.push({
+                end: statement.end,
+                start: statement.getStart(sourceFile),
+            });
+        }
+    }
+    return {
+        ranges,
+        topLevelBindingNames,
+    };
+}
+function getImportValueBindingNames(importClause) {
+    if (!importClause || importClause.isTypeOnly) {
+        return [];
+    }
+    const names = [];
+    if (importClause.name) {
+        names.push(importClause.name.text);
+    }
+    if (!importClause.namedBindings) {
+        return names;
+    }
+    if (ts.isNamespaceImport(importClause.namedBindings)) {
+        names.push(importClause.namedBindings.name.text);
+        return names;
+    }
+    for (const element of importClause.namedBindings.elements) {
+        if (!element.isTypeOnly) {
+            names.push(element.name.text);
+        }
+    }
+    return names;
+}
+function getServerOnlyImportInfo(sourceFile, serverOnlyRanges, id, root) {
+    const removableImports = new Set();
+    const valueImports = new Map();
+    const throwClientBoundaryError = (specifier, reason) => {
+        throw new Error(`[vorzelajs-server-only] ${formatRelativeId(id, root)} ${reason} "${specifier}". `
+            + 'Move that usage into loader/beforeLoad/validateSearch, or keep it behind a .server import that is only referenced there.');
+    };
+    const visitForRouteViolations = (node) => {
+        if (ts.isExportDeclaration(node)
+            && node.moduleSpecifier
+            && ts.isStringLiteral(node.moduleSpecifier)
+            && isServerOnlyModuleSpecifier(node.moduleSpecifier.text)) {
+            throwClientBoundaryError(node.moduleSpecifier.text, 're-exports a .server module from client-visible route code:');
+        }
+        if (ts.isCallExpression(node)
+            && node.expression.kind === ts.SyntaxKind.ImportKeyword
+            && node.arguments.length === 1
+            && ts.isStringLiteral(node.arguments[0])
+            && isServerOnlyModuleSpecifier(node.arguments[0].text)
+            && !isNodeWithinRanges(node, sourceFile, serverOnlyRanges)) {
+            throwClientBoundaryError(node.arguments[0].text, 'uses a .server dynamic import outside server-only route code:');
+        }
+        ts.forEachChild(node, visitForRouteViolations);
+    };
+    visitForRouteViolations(sourceFile);
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) {
+            continue;
+        }
+        const specifier = statement.moduleSpecifier.text;
+        if (!isServerOnlyModuleSpecifier(specifier)) {
+            continue;
+        }
+        if (!statement.importClause) {
+            throwClientBoundaryError(specifier, 'contains a side-effect .server import in client-visible route code:');
+        }
+        const bindingNames = getImportValueBindingNames(statement.importClause);
+        if (bindingNames.length === 0) {
+            continue;
+        }
+        removableImports.add(statement);
+        for (const bindingName of bindingNames) {
+            valueImports.set(bindingName, specifier);
+        }
+    }
+    if (valueImports.size === 0) {
+        return removableImports;
+    }
+    const visitForBindingUsage = (node) => {
+        if (ts.isImportDeclaration(node)) {
+            return;
+        }
+        if (ts.isIdentifier(node) && isIdentifierReference(node)) {
+            const specifier = valueImports.get(node.text);
+            if (specifier && !isNodeWithinRanges(node, sourceFile, serverOnlyRanges)) {
+                throwClientBoundaryError(specifier, `references .server binding "${node.text}" outside server-only route code from`);
+            }
+        }
+        ts.forEachChild(node, visitForBindingUsage);
+    };
+    visitForBindingUsage(sourceFile);
+    return removableImports;
+}
+function stripTopLevelServerOnlyStatement(statement, bindingNames) {
+    if (ts.isFunctionDeclaration(statement) && statement.name && bindingNames.has(statement.name.text)) {
+        return null;
+    }
+    if (ts.isVariableStatement(statement)) {
+        const keptDeclarations = statement.declarationList.declarations.filter((declaration) => {
+            return !getBindingNames(declaration.name).some((name) => bindingNames.has(name));
+        });
+        if (keptDeclarations.length === 0) {
+            return null;
+        }
+        if (keptDeclarations.length !== statement.declarationList.declarations.length) {
+            return ts.factory.updateVariableStatement(statement, statement.modifiers, ts.factory.updateVariableDeclarationList(statement.declarationList, keptDeclarations));
+        }
+    }
+    return statement;
+}
+function stripRouteServerProperties(code, id, root) {
+    const normalizedId = stripQuerySuffix(id);
+    const scriptKind = normalizedId.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+    const sourceFile = ts.createSourceFile(normalizedId, code, ts.ScriptTarget.Latest, true, scriptKind);
+    const { ranges: serverOnlyRanges, topLevelBindingNames } = collectRouteServerOnlyContext(sourceFile);
+    const removableImports = getServerOnlyImportInfo(sourceFile, serverOnlyRanges, normalizedId, root);
+    let changed = false;
+    const transformer = (context) => {
+        const visitor = (node) => {
+            if (ts.isObjectLiteralExpression(node) && isRouteOptionsObject(node)) {
+                const filteredProperties = node.properties.filter((property) => {
+                    const name = getObjectLiteralElementName(property);
+                    const shouldKeep = !name || !ROUTE_SERVER_PROPERTY_NAMES.has(name);
+                    if (!shouldKeep) {
+                        changed = true;
+                    }
+                    return shouldKeep;
+                });
+                if (filteredProperties.length !== node.properties.length) {
+                    return ts.factory.updateObjectLiteralExpression(node, filteredProperties);
+                }
+            }
+            return ts.visitEachChild(node, visitor, context);
+        };
+        return (rootNode) => {
+            const nextStatements = [];
+            for (const statement of rootNode.statements) {
+                if (ts.isImportDeclaration(statement) && removableImports.has(statement)) {
+                    changed = true;
+                    continue;
+                }
+                const strippedStatement = stripTopLevelServerOnlyStatement(statement, topLevelBindingNames);
+                if (!strippedStatement) {
+                    changed = true;
+                    continue;
+                }
+                nextStatements.push(ts.visitNode(strippedStatement, visitor));
+            }
+            if (!changed) {
+                return rootNode;
+            }
+            return ts.factory.updateSourceFile(rootNode, nextStatements);
+        };
+    };
+    const result = ts.transform(sourceFile, [transformer]);
+    try {
+        if (!changed) {
+            return null;
+        }
+        const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+        return printer.printFile(result.transformed[0]);
+    }
+    finally {
+        result.dispose();
+    }
+}
+function assertNoServerOnlyImportsInClientFile(code, id, sourceRoot, root) {
+    const normalizedId = stripQuerySuffix(id);
+    if (!normalizedId.startsWith(`${sourceRoot}${path.sep}`) || isRouteFileId(normalizedId)) {
+        return;
+    }
+    const scriptKind = normalizedId.endsWith('.tsx')
+        ? ts.ScriptKind.TSX
+        : normalizedId.endsWith('.jsx')
+            ? ts.ScriptKind.JSX
+            : normalizedId.endsWith('.js')
+                ? ts.ScriptKind.JS
+                : ts.ScriptKind.TS;
+    const sourceFile = ts.createSourceFile(normalizedId, code, ts.ScriptTarget.Latest, true, scriptKind);
+    const throwClientBoundaryError = (specifier) => {
+        throw new Error(`[vorzelajs-server-only] ${formatRelativeId(id, root)} imports .server module "${specifier}". `
+            + 'Only route loader/beforeLoad/validateSearch code may reference .server modules in the client build.');
+    };
+    const visit = (node) => {
+        if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node))
+            && node.moduleSpecifier
+            && ts.isStringLiteral(node.moduleSpecifier)
+            && isServerOnlyModuleSpecifier(node.moduleSpecifier.text)) {
+            throwClientBoundaryError(node.moduleSpecifier.text);
+        }
+        if (ts.isCallExpression(node)
+            && node.expression.kind === ts.SyntaxKind.ImportKeyword
+            && node.arguments.length === 1
+            && ts.isStringLiteral(node.arguments[0])
+            && isServerOnlyModuleSpecifier(node.arguments[0].text)) {
+            throwClientBoundaryError(node.arguments[0].text);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+}
+export function vorzelaServerOnlyPlugin() {
+    let root = process.cwd();
+    let sourceRoot = path.resolve(root, 'src');
+    return {
+        name: 'vorzelajs-server-only-support',
+        enforce: 'pre',
+        configResolved(config) {
+            root = config.root;
+            sourceRoot = path.resolve(root, 'src');
+        },
+        transform(code, id) {
+            assertNoServerOnlyImportsInClientFile(code, id, sourceRoot, root);
+            if (!isRouteFileId(id)) {
+                return null;
+            }
+            const modified = stripRouteServerProperties(code, id, root);
+            if (!modified) {
+                return null;
+            }
+            return { code: modified, map: null };
+        },
+    };
+}