rimecms 0.31.4 → 0.32.0

package/dist/core/dev/codegen/sanitize/index.server.js

@@ -0,0 +1,834 @@
+// @ts-nocheck
+import { generate } from '@babel/generator';
+import * as t from '@babel/types';
+import { babelParse } from 'ast-kit';
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '../../../logger.server.js';
+import { CONFIG_DIR, GENERATED_DIR, OUTPUT_DIR } from '../../constants.server.js';
+
+/**
+ * $ prefix-based sanitizer that rules:
+ * - All server-only config properties begin with $ (e.g., $url, $hooks)
+ * - All server-only field methods begin with $ (e.g., $beforeSave, $beforeRead)
+ * - Content must be pure functions or imports from .server.ts files
+ * - Outputs to .generated folder, preserving original folder structure
+ */
+
+// The top-level config — real, hand-authored. Unlike every other .server.ts file under
+// +rime/ (copied verbatim, server-only, no client counterpart needed), this one always needs
+// a sanitized client copy too — the panel still needs +rime.generated/rime.config.ts.
+const TOP_LEVEL_CONFIG = 'rime.config.server.ts';
+
+export async function sanitize() {
+  const root = process.cwd();
+  const configDir = path.resolve(root, CONFIG_DIR);
+  const outputDir = path.resolve(root, GENERATED_DIR);
+
+  logger.info('Sanitizing config...');
+
+  // List all existing files recursively in the output directory
+  const existingFiles = new Set();
+  if (fs.existsSync(outputDir)) {
+    const scanExistingFiles = (dir) => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          scanExistingFiles(fullPath);
+        } else {
+          existingFiles.add(path.relative(outputDir, fullPath));
+        }
+      }
+    };
+    scanExistingFiles(outputDir);
+  } else {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Track files that will be written during sanitization
+  const outputFiles = new Set();
+
+  // Track files that get split into both client and server versions
+  const splitFiles = new Set();
+
+  // Scan all TypeScript files (excluding .server.ts)
+  const allFiles = await scanConfigFiles(configDir);
+
+  // Pre-scan files to determine which ones will be split (contain server content)
+  for (const filePath of allFiles) {
+    const relativePath = path.relative(configDir, filePath);
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: false });
+      const analysis = analyzeFile(ast);
+      if (analysis.hasServerContent) {
+        // Normalize to forward slashes to match how imports are compared later
+        splitFiles.add(relativePath.split(path.sep).join('/'));
+      }
+    } catch (err) {
+      logger.warn(`Failed to analyze ${relativePath} during pre-scan: ${err.message}`);
+    }
+  }
+
+  // Also scan and copy all existing .server.ts files — except the top-level config, which
+  // gets its own client+server split below instead of a plain verbatim copy.
+  const serverFiles = (await scanServerFiles(configDir)).filter(
+    (filePath) => path.relative(configDir, filePath) !== TOP_LEVEL_CONFIG
+  );
+
+  // Scan and copy all other files (non-.ts files like .svelte, .json, etc.)
+  const otherFiles = await scanOtherFiles(configDir);
+
+  // Top-level config split: same client/server treatment as every other split file below,
+  // just addressed by its fixed name instead of found via the scan (it's .server.ts-suffixed,
+  // so scanConfigFiles/allFiles never sees it). Runs after the pre-scan above so splitFiles is
+  // fully populated — this file's own `import { Pages } from './pages'`-style imports need to
+  // know which nested files themselves got split.
+  await processTopLevelConfig(configDir, outputDir, outputFiles, splitFiles);
+
+  for (const filePath of allFiles) {
+    const relativePath = path.relative(configDir, filePath);
+    logger.debug(`   Processing: ${relativePath}`);
+
+    // Check if corresponding .server.ts already exists
+    const originalServerPath = filePath.replace('.ts', '.server.ts');
+    if (fs.existsSync(originalServerPath)) {
+      throw new Error(
+        `Error: ${originalServerPath} already exists. Remove it before running sanitization.`
+      );
+    }
+
+    // Process the file and output to .generated
+    await processConfigFile(filePath, configDir, outputDir, outputFiles, splitFiles);
+  }
+
+  // Copy existing .server.ts files
+  for (const serverFilePath of serverFiles) {
+    const relativePath = path.relative(configDir, serverFilePath);
+    const outputPath = path.join(outputDir, relativePath);
+    const outputDirPath = path.dirname(outputPath);
+
+    if (!fs.existsSync(outputDirPath)) {
+      fs.mkdirSync(outputDirPath, { recursive: true });
+    }
+
+    const content = fs.readFileSync(serverFilePath, 'utf-8');
+    const relativeOutputPath = path.relative(outputDir, outputPath);
+    outputFiles.add(relativeOutputPath);
+
+    // Only write if content is different or file doesn't exist
+    if (shouldWriteFile(outputPath, content)) {
+      fs.writeFileSync(outputPath, content);
+      logger.debug(`   Copied: ${relativePath}`);
+    }
+  }
+
+  // Copy other files (.svelte, .json, etc.)
+  for (const otherFilePath of otherFiles) {
+    const relativePath = path.relative(configDir, otherFilePath);
+    const outputPath = path.join(outputDir, relativePath);
+    const outputDirPath = path.dirname(outputPath);
+
+    if (!fs.existsSync(outputDirPath)) {
+      fs.mkdirSync(outputDirPath, { recursive: true });
+    }
+
+    const content = fs.readFileSync(otherFilePath, 'utf-8');
+    const relativeOutputPath = path.relative(outputDir, outputPath);
+    outputFiles.add(relativeOutputPath);
+
+    // Only write if content is different or file doesn't exist
+    if (shouldWriteFile(outputPath, content)) {
+      fs.writeFileSync(outputPath, content);
+      logger.debug(`   Copied: ${relativePath}`);
+    }
+  }
+
+  // Delete files that exist in current list but not in output list. schema.server.ts is
+  // excluded — write.server.ts owns it (writes it straight into OUTPUT_DIR, see schemaPath()
+  // in constants.ts), sanitize() never adds it to outputFiles, so without this exclusion
+  // every sanitize run deletes it out from under write()'s own cache guard.
+  const SCHEMA_FILE = 'schema.server.ts';
+  for (const existingFile of existingFiles) {
+    if (existingFile !== SCHEMA_FILE && !outputFiles.has(existingFile)) {
+      const fileToDelete = path.join(outputDir, existingFile);
+      fs.unlinkSync(fileToDelete);
+      logger.debug(`   Deleted: ${existingFile}`);
+    }
+  }
+
+  logger.info('Sanitization complete');
+}
+
+/**
+ * The top-level config (src/lib/+rime/rime.config.server.ts) — real, hand-authored. Client
+ * copy via analyzeFile + sanitizeClientAst + removeUnusedImports, written into
+ * +rime.generated/, plus a server copy via updateServerImports so its own imports of nested
+ * split files resolve like every other split file's do.
+ */
+async function processTopLevelConfig(configDir, outputDir, outputFiles, splitFiles) {
+  const sourcePath = path.join(configDir, TOP_LEVEL_CONFIG);
+  if (!fs.existsSync(sourcePath)) return; // ensureUserConfigExist() already guards this
+
+  const content = fs.readFileSync(sourcePath, 'utf-8');
+  const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: false });
+  const analysis = analyzeFile(ast);
+
+  const clientPath = path.join(outputDir, 'rime.config.ts');
+  const serverPath = path.join(outputDir, TOP_LEVEL_CONFIG);
+  outputFiles.add(path.relative(outputDir, clientPath));
+  outputFiles.add(path.relative(outputDir, serverPath));
+
+  const clientAst = sanitizeClientAst(ast, analysis);
+  const cleanedAst = removeUnusedImports(clientAst);
+  const clientCode = generate(cleanedAst, { compact: false, comments: true }).code;
+  if (shouldWriteFile(clientPath, clientCode)) {
+    fs.writeFileSync(clientPath, clientCode);
+    logger.debug(`   Sanitized: rime.config.ts`);
+  }
+
+  const serverContent = updateServerImports(content, splitFiles, '.');
+  if (shouldWriteFile(serverPath, serverContent)) {
+    fs.writeFileSync(serverPath, serverContent);
+    logger.debug(`   Created: ${TOP_LEVEL_CONFIG}`);
+  }
+}
+
+async function scanConfigFiles(configDir) {
+  const files = [];
+
+  function scanDir(currentDir) {
+    const items = fs.readdirSync(currentDir, { withFileTypes: true });
+
+    for (const item of items) {
+      const fullPath = path.join(currentDir, item.name);
+
+      if (item.isDirectory() && item.name !== OUTPUT_DIR) {
+        scanDir(fullPath);
+      } else if (item.isFile() && item.name.endsWith('.ts') && !item.name.endsWith('.server.ts')) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  scanDir(configDir);
+  return files;
+}
+
+async function scanServerFiles(configDir) {
+  const files = [];
+
+  function scanDir(currentDir) {
+    const items = fs.readdirSync(currentDir, { withFileTypes: true });
+
+    for (const item of items) {
+      const fullPath = path.join(currentDir, item.name);
+
+      if (item.isDirectory() && item.name !== OUTPUT_DIR) {
+        scanDir(fullPath);
+      } else if (item.isFile() && item.name.endsWith('.server.ts')) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  scanDir(configDir);
+  return files;
+}
+
+async function scanOtherFiles(configDir) {
+  const files = [];
+
+  function scanDir(currentDir) {
+    const items = fs.readdirSync(currentDir, { withFileTypes: true });
+
+    for (const item of items) {
+      const fullPath = path.join(currentDir, item.name);
+
+      if (item.isDirectory() && item.name !== OUTPUT_DIR) {
+        scanDir(fullPath);
+      } else if (item.isFile() && !item.name.endsWith('.ts')) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  scanDir(configDir);
+  return files;
+}
+
+async function processConfigFile(originalPath, configDir, outputDir, outputFiles, splitFiles) {
+  const content = fs.readFileSync(originalPath, 'utf-8');
+  const relativePath = path.relative(configDir, originalPath);
+
+  try {
+    const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: false });
+
+    // Analyze the file to find $ patterns
+    const analysis = analyzeFile(ast);
+
+    if (!analysis.hasServerContent) {
+      // Just copy the original file to .generated
+      const outputPath = path.join(outputDir, relativePath);
+      const outputDirPath = path.dirname(outputPath);
+      if (!fs.existsSync(outputDirPath)) {
+        fs.mkdirSync(outputDirPath, { recursive: true });
+      }
+      const relativeOutputPath = path.relative(outputDir, outputPath);
+      outputFiles.add(relativeOutputPath);
+
+      // Only write if content is different or file doesn't exist
+      if (shouldWriteFile(outputPath, content)) {
+        fs.writeFileSync(outputPath, content);
+      }
+      return;
+    }
+
+    // Calculate output paths
+    const clientPath = path.join(outputDir, relativePath);
+    const serverPath = path.join(outputDir, relativePath.replace('.ts', '.server.ts'));
+
+    // Ensure output directories exist
+    const clientDir = path.dirname(clientPath);
+    const serverDir = path.dirname(serverPath);
+    if (!fs.existsSync(clientDir)) {
+      fs.mkdirSync(clientDir, { recursive: true });
+    }
+    if (!fs.existsSync(serverDir)) {
+      fs.mkdirSync(serverDir, { recursive: true });
+    }
+
+    // Track output files
+    const relativeServerPath = path.relative(outputDir, serverPath);
+    const relativeClientPath = path.relative(outputDir, clientPath);
+    outputFiles.add(relativeServerPath);
+    outputFiles.add(relativeClientPath);
+
+    // Track this as a split file (has both client and server versions)
+    const relativeOriginalPath = path.relative(configDir, originalPath);
+    splitFiles.add(relativeOriginalPath);
+
+    // Create server version (full content with updated imports)
+    const serverContent = updateServerImports(content, splitFiles, path.dirname(relativePath));
+    if (shouldWriteFile(serverPath, serverContent)) {
+      fs.writeFileSync(serverPath, serverContent);
+      logger.debug(`   Created: ${relativeServerPath}`);
+    }
+
+    // Create sanitized client version
+    const clientAst = sanitizeClientAst(ast, analysis);
+    // Clean up unused imports
+    const cleanedAst = removeUnusedImports(clientAst);
+    const clientCode = generate(cleanedAst, { compact: false, comments: true }).code;
+    if (shouldWriteFile(clientPath, clientCode)) {
+      fs.writeFileSync(clientPath, clientCode);
+      logger.debug(`   Sanitized: ${relativeClientPath}`);
+    }
+  } catch (error) {
+    logger.error(`    Failed to process ${originalPath}:`, error.message);
+    throw error;
+  }
+}
+
+function analyzeFile(ast) {
+  const analysis = {
+    hasServerContent: false,
+    serverImports: new Set(),
+    serverFunctions: new Set(),
+    dollarProperties: new Set(),
+    dollarMethods: new Set(),
+    functionsUsedInDollarProps: new Set()
+  };
+
+  // Walk the AST to find $ patterns
+  function walkNode(node) {
+    if (!node || typeof node !== 'object') return;
+
+    // Find imports from .server.ts files
+    if (t.isImportDeclaration(node)) {
+      const source = node.source.value;
+      if (source.includes('.server')) {
+        analysis.hasServerContent = true;
+        // Mark all imported identifiers as server
+        node.specifiers.forEach((spec) => {
+          if (t.isImportSpecifier(spec) || t.isImportDefaultSpecifier(spec)) {
+            analysis.serverImports.add(spec.local.name);
+          }
+        });
+      }
+    }
+
+    // Find $ prefixed object properties
+    if (t.isObjectProperty(node) && t.isIdentifier(node.key) && node.key.name.startsWith('$')) {
+      analysis.hasServerContent = true;
+      analysis.dollarProperties.add(node.key.name);
+      // Track functions used within $ properties
+      findFunctionsInNode(node.value, analysis.functionsUsedInDollarProps);
+    }
+
+    // Find $ prefixed method calls (e.g., .$beforeSave())
+    if (
+      t.isCallExpression(node) &&
+      t.isMemberExpression(node.callee) &&
+      t.isIdentifier(node.callee.property) &&
+      node.callee.property.name.startsWith('$')
+    ) {
+      analysis.hasServerContent = true;
+      analysis.dollarMethods.add(node.callee.property.name);
+    }
+
+    // Find local functions that might be used by $ methods
+    if (
+      t.isVariableDeclarator(node) &&
+      t.isIdentifier(node.id) &&
+      (t.isArrowFunctionExpression(node.init) || t.isFunctionExpression(node.init))
+    ) {
+      // Check if this function is used by server content
+      if (isFunctionUsedByServerContent(node.id.name, ast, analysis)) {
+        analysis.serverFunctions.add(node.id.name);
+      }
+    }
+
+    if (t.isFunctionDeclaration(node) && node.id) {
+      if (isFunctionUsedByServerContent(node.id.name, ast, analysis)) {
+        analysis.serverFunctions.add(node.id.name);
+      }
+    }
+
+    // Recursively walk child nodes
+    for (const key in node) {
+      if (Object.prototype.hasOwnProperty.call(node, key) && key !== 'parent') {
+        const child = node[key];
+        if (Array.isArray(child)) {
+          child.forEach(walkNode);
+        } else if (child && typeof child === 'object') {
+          walkNode(child);
+        }
+      }
+    }
+  }
+
+  walkNode(ast);
+  return analysis;
+}
+
+function isFunctionUsedByServerContent(functionName, ast) {
+  // Simple heuristic: if function is used as argument to $ methods or imported from server
+  let isUsedByServer = false;
+
+  function checkUsage(node) {
+    if (!node || typeof node !== 'object') return;
+
+    // Check if function is used as argument to $ methods
+    if (
+      t.isCallExpression(node) &&
+      t.isMemberExpression(node.callee) &&
+      t.isIdentifier(node.callee.property) &&
+      node.callee.property.name.startsWith('$')
+    ) {
+      // Check if our function is used as an argument
+      node.arguments.forEach((arg) => {
+        if (t.isIdentifier(arg) && arg.name === functionName) {
+          isUsedByServer = true;
+        }
+      });
+    }
+
+    // Check if function is used in $ properties
+    if (t.isObjectProperty(node) && t.isIdentifier(node.key) && node.key.name.startsWith('$')) {
+      function checkValue(value) {
+        if (t.isIdentifier(value) && value.name === functionName) {
+          isUsedByServer = true;
+        } else if (t.isObjectExpression(value)) {
+          value.properties.forEach((prop) => {
+            if (t.isObjectProperty(prop)) {
+              checkValue(prop.value);
+            }
+          });
+        } else if (t.isArrayExpression(value)) {
+          value.elements.forEach((el) => {
+            if (el) checkValue(el);
+          });
+        }
+      }
+
+      checkValue(node.value);
+    }
+
+    // Recursively check child nodes
+    for (const key in node) {
+      if (Object.prototype.hasOwnProperty.call(node, key) && key !== 'parent') {
+        const child = node[key];
+        if (Array.isArray(child)) {
+          child.forEach(checkUsage);
+        } else if (child && typeof child === 'object') {
+          checkUsage(child);
+        }
+      }
+    }
+  }
+
+  checkUsage(ast);
+  return isUsedByServer;
+}
+
+function findFunctionsInNode(node, functionsSet) {
+  if (!node || typeof node !== 'object') return;
+
+  if (t.isIdentifier(node)) {
+    functionsSet.add(node.name);
+  } else if (t.isArrayExpression(node)) {
+    node.elements.forEach((element) => {
+      if (element) findFunctionsInNode(element, functionsSet);
+    });
+  } else if (t.isObjectExpression(node)) {
+    node.properties.forEach((prop) => {
+      if (t.isObjectProperty(prop)) {
+        findFunctionsInNode(prop.value, functionsSet);
+      }
+    });
+  }
+
+  // Recursively check child nodes
+  for (const key in node) {
+    if (Object.prototype.hasOwnProperty.call(node, key) && key !== 'parent') {
+      const child = node[key];
+      if (Array.isArray(child)) {
+        child.forEach((item) => findFunctionsInNode(item, functionsSet));
+      } else if (child && typeof child === 'object') {
+        findFunctionsInNode(child, functionsSet);
+      }
+    }
+  }
+}
+
+function sanitizeClientAst(ast, analysis) {
+  const clonedAst = JSON.parse(JSON.stringify(ast));
+
+  function sanitizeNode(node) {
+    if (!node || typeof node !== 'object') return node;
+
+    // Remove imports from .server.ts files
+    if (t.isImportDeclaration(node)) {
+      const source = node.source.value;
+      if (source.includes('.server')) {
+        return null; // Mark for removal
+      }
+    }
+
+    // Replace rime with rimeClient in imports
+    if (t.isImportDeclaration(node)) {
+      node.specifiers.forEach((spec) => {
+        if (
+          t.isImportSpecifier(spec) &&
+          t.isIdentifier(spec.imported) &&
+          spec.imported.name === 'rime'
+        ) {
+          spec.imported.name = 'rimeClient';
+          if (t.isIdentifier(spec.local)) {
+            spec.local.name = 'rimeClient';
+          }
+        }
+      });
+    }
+
+    // Replace rime function calls with rimeClient
+    if (t.isCallExpression(node) && t.isIdentifier(node.callee) && node.callee.name === 'rime') {
+      node.callee.name = 'rimeClient';
+    }
+
+    // Remove $ prefixed object properties
+    if (t.isObjectExpression(node)) {
+      node.properties = node.properties.filter((prop) => {
+        if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name.startsWith('$')) {
+          return false; // Remove $ properties
+        }
+        return true;
+      });
+    }
+
+    // Remove $ prefixed method calls from call chains
+    if (
+      t.isCallExpression(node) &&
+      t.isMemberExpression(node.callee) &&
+      t.isIdentifier(node.callee.property) &&
+      node.callee.property.name.startsWith('$')
+    ) {
+      // Return the object the method was called on (strip the method call)
+      return sanitizeNode(node.callee.object);
+    }
+
+    // Remove server function declarations and functions only used in $ properties
+    if (t.isVariableDeclaration(node)) {
+      node.declarations = node.declarations.filter((declarator) => {
+        if (t.isIdentifier(declarator.id)) {
+          const name = declarator.id.name;
+          // Remove if it's a server function or only used in $ properties
+          if (analysis.serverFunctions.has(name) || analysis.functionsUsedInDollarProps.has(name)) {
+            return false;
+          }
+        }
+        return true;
+      });
+      // If no declarations left, mark for removal
+      if (node.declarations.length === 0) {
+        return null;
+      }
+    }
+
+    if (t.isFunctionDeclaration(node) && node.id) {
+      const name = node.id.name;
+      // Remove if it's a server function or only used in $ properties
+      if (analysis.serverFunctions.has(name) || analysis.functionsUsedInDollarProps.has(name)) {
+        return null;
+      }
+    }
+
+    // Recursively sanitize child nodes
+    for (const key in node) {
+      if (Object.prototype.hasOwnProperty.call(node, key) && key !== 'parent') {
+        const child = node[key];
+        if (Array.isArray(child)) {
+          node[key] = child.map(sanitizeNode).filter((item) => item !== null);
+        } else if (child && typeof child === 'object') {
+          const sanitized = sanitizeNode(child);
+          if (sanitized === null) {
+            delete node[key];
+          } else {
+            node[key] = sanitized;
+          }
+        }
+      }
+    }
+
+    return node;
+  }
+
+  // Apply sanitization
+  sanitizeNode(clonedAst);
+
+  // Remove null body items (removed imports/declarations)
+  if (clonedAst.body) {
+    clonedAst.body = clonedAst.body.filter((item) => item !== null);
+  }
+
+  // Final cleanup: remove orphaned expression statements (standalone identifiers)
+  if (clonedAst.body) {
+    clonedAst.body = clonedAst.body.filter((node) => {
+      // Remove expression statements that are just standalone identifiers
+      if (t.isExpressionStatement(node) && t.isIdentifier(node.expression)) {
+        return false; // Remove orphaned references like "legendField;"
+      }
+      return true;
+    });
+  }
+
+  return clonedAst;
+}
+
+function removeUnusedImports(ast) {
+  const clonedAst = JSON.parse(JSON.stringify(ast));
+
+  // Collect all imported identifiers
+  const importedIdentifiers = new Map(); // identifier -> import declaration
+  const usedIdentifiers = new Set();
+
+  // First pass: collect all imports
+  function collectImports(node) {
+    if (t.isImportDeclaration(node)) {
+      node.specifiers.forEach((spec) => {
+        let localName;
+        if (t.isImportDefaultSpecifier(spec)) {
+          localName = spec.local.name;
+        } else if (t.isImportSpecifier(spec)) {
+          localName = spec.local.name;
+        } else if (t.isImportNamespaceSpecifier(spec)) {
+          localName = spec.local.name;
+        }
+
+        if (localName) {
+          importedIdentifiers.set(localName, node);
+        }
+      });
+    }
+  }
+
+  // Second pass: find used identifiers
+  function findUsedIdentifiers(node) {
+    if (!node || typeof node !== 'object') return;
+
+    // Skip import declarations and variable declarators' ids to avoid marking declarations as usage
+    if (t.isImportDeclaration(node)) {
+      return;
+    }
+
+    if (t.isVariableDeclarator(node)) {
+      // Only check the init, not the id
+      if (node.init) {
+        findUsedIdentifiers(node.init);
+      }
+      return;
+    }
+
+    if (t.isFunctionDeclaration(node)) {
+      // Only check the body, not the id and params
+      if (node.body) {
+        findUsedIdentifiers(node.body);
+      }
+      return;
+    }
+
+    // Skip $ prefixed object properties to avoid marking their content as used
+    if (t.isObjectProperty(node) && t.isIdentifier(node.key) && node.key.name.startsWith('$')) {
+      return;
+    }
+
+    if (t.isIdentifier(node)) {
+      usedIdentifiers.add(node.name);
+    }
+
+    // Recursively check child nodes
+    for (const key in node) {
+      if (Object.prototype.hasOwnProperty.call(node, key) && key !== 'parent') {
+        const child = node[key];
+        if (Array.isArray(child)) {
+          child.forEach(findUsedIdentifiers);
+        } else if (child && typeof child === 'object') {
+          findUsedIdentifiers(child);
+        }
+      }
+    }
+  }
+
+  // Collect imports and find usage
+  clonedAst.body.forEach(collectImports);
+  clonedAst.body.forEach(findUsedIdentifiers);
+
+  // Remove unused imports
+  clonedAst.body = clonedAst.body.filter((node) => {
+    if (t.isImportDeclaration(node)) {
+      // Filter out unused specifiers
+      node.specifiers = node.specifiers.filter((spec) => {
+        let localName;
+        if (t.isImportDefaultSpecifier(spec)) {
+          localName = spec.local.name;
+        } else if (t.isImportSpecifier(spec)) {
+          localName = spec.local.name;
+        } else if (t.isImportNamespaceSpecifier(spec)) {
+          localName = spec.local.name;
+        }
+
+        return localName && usedIdentifiers.has(localName);
+      });
+
+      // Keep the import declaration only if it has remaining specifiers
+      return node.specifiers.length > 0;
+    }
+    return true;
+  });
+
+  return clonedAst;
+}
+
+/**
+ * Updates imports in server files to use server versions of split modules
+ */
+export function updateServerImports(content, splitFiles, currentDir) {
+  try {
+    const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: false });
+
+    let hasChanges = false;
+
+    // Helper to normalize paths for comparison with splitFiles entries
+    const normalizeForCompare = (p) =>
+      p
+        .replace(/^\.\/?/, '')
+        .split(path.sep)
+        .join('/');
+    const splitFilesSet = new Set(Array.from(splitFiles).map((s) => normalizeForCompare(s)));
+
+    // Walk through all import declarations
+    for (const node of ast.body) {
+      if (t.isImportDeclaration(node) && t.isStringLiteral(node.source)) {
+        const importPath = node.source.value;
+
+        // Skip absolute imports and package imports
+        if (!importPath.startsWith('./') && !importPath.startsWith('../')) {
+          continue;
+        }
+
+        // Skip already server imports
+        if (importPath.includes('.server')) continue;
+
+        // Normalize import path: remove trailing slashes and explicit extensions
+        const cleanedImport = importPath.replace(/\/+$/, '');
+        const importNoExt = cleanedImport.replace(/(\.js|\.ts)$/, '');
+
+        // Build candidate relative paths (relative to config dir)
+        const candidateFile = path.normalize(path.join(currentDir, importNoExt + '.ts'));
+        const candidateIndex = path.normalize(path.join(currentDir, importNoExt, 'index.ts'));
+
+        const candidateFileNorm = normalizeForCompare(candidateFile);
+        const candidateIndexNorm = normalizeForCompare(candidateIndex);
+
+        let matched = null;
+        let matchedIsIndex = false;
+
+        if (splitFilesSet.has(candidateFileNorm)) {
+          matched = candidateFileNorm;
+          matchedIsIndex = false;
+        } else if (splitFilesSet.has(candidateIndexNorm)) {
+          matched = candidateIndexNorm;
+          matchedIsIndex = true;
+        }
+
+        if (matched) {
+          // Build new import path: prefer .server.js so runtime imports point to JS server files
+          let newImportPath;
+          if (matchedIsIndex) {
+            newImportPath = importNoExt + '/index.server.js';
+          } else {
+            newImportPath = importNoExt + '.server.js';
+          }
+
+          // Set the node's source value and ensure it renders with single quotes
+          node.source.value = newImportPath;
+          if (!node.source.extra || typeof node.source.extra !== 'object') {
+            node.source.extra = {};
+          }
+          node.source.extra.raw = `'${newImportPath}'`;
+          node.source.extra.rawValue = newImportPath;
+          hasChanges = true;
+        }
+      }
+    }
+
+    if (hasChanges) {
+      return generate(ast, { compact: false, comments: true }).code;
+    }
+
+    return content;
+  } catch (error) {
+    // If parsing fails, return original content
+    logger.warn(`Failed to update imports in server file: ${error.message}`);
+    return content;
+  }
+}
+
+/**
+ * Checks if a file should be written by comparing content with existing file
+ */
+function shouldWriteFile(filePath, newContent) {
+  if (!fs.existsSync(filePath)) {
+    return true;
+  }
+
+  const existingContent = fs.readFileSync(filePath, 'utf-8');
+  return existingContent !== newContent;
+}
+
+// Run the sanitizer if this script is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  sanitize().catch(console.error);
+}