@jay-framework/compiler-jay-stack 0.9.0 → 0.10.0

package/dist/index.d.ts

@@ -2,6 +2,23 @@ import { Plugin } from 'vite';
 import { JayRollupConfig } from '@jay-framework/vite-plugin';
 export { JayRollupConfig } from '@jay-framework/vite-plugin';
 
+interface ImportChainTrackerOptions {
+    /** Enable verbose logging */
+    verbose?: boolean;
+    /** Additional modules to treat as server-only */
+    additionalServerModules?: string[];
+    /** Additional package patterns to treat as server-only */
+    additionalServerPatterns?: string[];
+}
+/**
+ * Creates a Vite plugin that tracks import chains and logs when
+ * server-only modules are imported in client builds.
+ *
+ * This helps debug issues where server code is accidentally pulled
+ * into client bundles.
+ */
+declare function createImportChainTracker(options?: ImportChainTrackerOptions): Plugin;
+
 type BuildEnvironment = 'client' | 'server';
 /**
  * Transform Jay Stack component builder chains to strip environment-specific code
@@ -16,12 +33,103 @@ declare function transformJayStackBuilder(code: string, filePath: string, enviro
     map?: any;
 };
 
+/**
+ * Transform action imports for client builds.
+ *
+ * On the server, action imports remain unchanged (handlers are executed directly).
+ * On the client, action imports are replaced with createActionCaller() calls.
+ *
+ * Example:
+ * ```typescript
+ * // Source
+ * import { addToCart, searchProducts } from '../actions/cart.actions';
+ *
+ * // Client build output
+ * import { createActionCaller } from '@jay-framework/stack-client-runtime';
+ * const addToCart = createActionCaller('cart.addToCart', 'POST');
+ * const searchProducts = createActionCaller('products.search', 'GET');
+ * ```
+ */
+/**
+ * Metadata for a discovered action.
+ */
+interface ActionMetadata {
+    /** Unique action name (e.g., 'cart.addToCart') */
+    actionName: string;
+    /** HTTP method */
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /** Export name in the source module */
+    exportName: string;
+}
+/**
+ * Result of extracting actions from a module.
+ */
+interface ExtractedActions {
+    /** Path to the action module */
+    modulePath: string;
+    /** Actions exported from this module */
+    actions: ActionMetadata[];
+}
+/**
+ * Clears the action metadata cache (useful for testing/dev reload).
+ */
+declare function clearActionMetadataCache(): void;
+/**
+ * Checks if an import source refers to an action module.
+ */
+declare function isActionImport(importSource: string): boolean;
+/**
+ * Extracts action metadata from source code by parsing makeJayAction/makeJayQuery calls.
+ *
+ * @param sourceCode - The TypeScript source code
+ * @param filePath - Path to the file (for error messages)
+ * @returns Array of action metadata
+ */
+declare function extractActionsFromSource(sourceCode: string, filePath: string): ActionMetadata[];
+/**
+ * Transform result with source map support.
+ */
+interface TransformResult {
+    code: string;
+    map?: any;
+}
+/**
+ * Transforms action imports in client builds.
+ *
+ * Replaces imports from action modules with createActionCaller() calls.
+ *
+ * @param code - Source code to transform
+ * @param id - Module ID (file path)
+ * @param resolveActionModule - Function to resolve and load action module source
+ * @returns Transformed code or null if no transform needed
+ */
+declare function transformActionImports(code: string, id: string, resolveActionModule: (importSource: string, importer: string) => Promise<{
+    path: string;
+    code: string;
+} | null>): Promise<TransformResult | null>;
+
+interface JayStackCompilerOptions extends JayRollupConfig {
+    /**
+     * Enable import chain tracking for debugging server code leaking into client builds.
+     * When enabled, logs the full import chain when server-only modules are detected.
+     * @default false (but auto-enabled when DEBUG_IMPORTS=1 env var is set)
+     */
+    trackImports?: boolean | ImportChainTrackerOptions;
+}
 /**
  * Jay Stack Compiler - Handles both Jay runtime compilation and Jay Stack code splitting
  *
  * This plugin internally uses the jay:runtime plugin and adds Jay Stack-specific
  * transformations for client/server code splitting.
  *
+ * Environment detection is based on Vite's `options.ssr`:
+ * - `options.ssr = true` → server build (strip client code)
+ * - `options.ssr = false/undefined` → client build (strip server code)
+ *
+ * This works for both:
+ * - Dev server: SSR renders with server code, browser hydrates with client code
+ * - Package builds: Use `build.ssr = true/false` to control environment
+ *
  * Usage:
  * ```typescript
  * import { jayStackCompiler } from '@jay-framework/compiler-jay-stack';
@@ -33,9 +141,19 @@ declare function transformJayStackBuilder(code: string, filePath: string, enviro
  * });
  * ```
  *
- * @param jayOptions - Configuration for Jay runtime (passed to jay:runtime plugin)
- * @returns Array of Vite plugins [codeSplitPlugin, jayRuntimePlugin]
+ * To debug import chain issues (server code leaking to client):
+ * ```bash
+ * DEBUG_IMPORTS=1 npm run build
+ * ```
+ *
+ * Or enable in config:
+ * ```typescript
+ * ...jayStackCompiler({ trackImports: true })
+ * ```
+ *
+ * @param options - Configuration for Jay Stack compiler
+ * @returns Array of Vite plugins
  */
-declare function jayStackCompiler(jayOptions?: JayRollupConfig): Plugin[];
+declare function jayStackCompiler(options?: JayStackCompilerOptions): Plugin[];
 
-export { type BuildEnvironment, jayStackCompiler, transformJayStackBuilder };
+export { type ActionMetadata, type BuildEnvironment, type ExtractedActions, type ImportChainTrackerOptions, type JayStackCompilerOptions, clearActionMetadataCache, createImportChainTracker, extractActionsFromSource, isActionImport, jayStackCompiler, transformActionImports, transformJayStackBuilder };

package/dist/index.js

@@ -1,18 +1,27 @@
 import { jayRuntime } from "@jay-framework/vite-plugin";
 import tsBridge from "@jay-framework/typescript-bridge";
 import { flattenVariable, isImportModuleVariableRoot, mkTransformer, SourceFileBindingResolver, areFlattenedAccessChainsEqual } from "@jay-framework/compiler";
-const SERVER_METHODS = /* @__PURE__ */ new Set([
+import * as fs from "node:fs";
+import * as path from "node:path";
+const COMPONENT_SERVER_METHODS = /* @__PURE__ */ new Set([
   "withServices",
   "withLoadParams",
   "withSlowlyRender",
   "withFastRender"
 ]);
-const CLIENT_METHODS = /* @__PURE__ */ new Set([
-  "withInteractive",
-  "withContexts"
-]);
+const COMPONENT_CLIENT_METHODS = /* @__PURE__ */ new Set(["withInteractive", "withContexts"]);
+const INIT_SERVER_METHODS = /* @__PURE__ */ new Set(["withServer"]);
+const INIT_CLIENT_METHODS = /* @__PURE__ */ new Set(["withClient"]);
 function shouldRemoveMethod(methodName, environment) {
-  return environment === "client" && SERVER_METHODS.has(methodName) || environment === "server" && CLIENT_METHODS.has(methodName);
+  if (environment === "client" && COMPONENT_SERVER_METHODS.has(methodName))
+    return true;
+  if (environment === "server" && COMPONENT_CLIENT_METHODS.has(methodName))
+    return true;
+  if (environment === "client" && INIT_SERVER_METHODS.has(methodName))
+    return true;
+  if (environment === "server" && INIT_CLIENT_METHODS.has(methodName))
+    return true;
+  return false;
 }
 const { isCallExpression: isCallExpression$1, isPropertyAccessExpression: isPropertyAccessExpression$1, isIdentifier: isIdentifier$2, isStringLiteral } = tsBridge;
 function findBuilderMethodsToRemove(sourceFile, bindingResolver, environment) {
@@ -33,6 +42,7 @@ function findBuilderMethodsToRemove(sourceFile, bindingResolver, environment) {
   sourceFile.forEachChild(visit);
   return { callsToRemove, removedVariables };
 }
+const JAY_BUILDER_FUNCTIONS = /* @__PURE__ */ new Set(["makeJayStackComponent", "makeJayInit"]);
 function isPartOfJayStackChain(callExpr, bindingResolver) {
   let current = callExpr.expression;
   while (true) {
@@ -42,7 +52,7 @@ function isPartOfJayStackChain(callExpr, bindingResolver) {
       if (isIdentifier$2(current.expression)) {
         const variable = bindingResolver.explain(current.expression);
         const flattened = flattenVariable(variable);
-        if (flattened.path.length === 1 && flattened.path[0] === "makeJayStackComponent" && isImportModuleVariableRoot(flattened.root) && isStringLiteral(flattened.root.module) && flattened.root.module.text === "@jay-framework/fullstack-component")
+        if (flattened.path.length === 1 && JAY_BUILDER_FUNCTIONS.has(flattened.path[0]) && isImportModuleVariableRoot(flattened.root) && isStringLiteral(flattened.root.module) && flattened.root.module.text === "@jay-framework/fullstack-component")
           return true;
       }
       if (isPropertyAccessExpression$1(current.expression)) {
@@ -72,15 +82,15 @@ function collectVariablesFromArguments(args, bindingResolver, variables) {
 const {
   isIdentifier: isIdentifier$1,
   isImportDeclaration: isImportDeclaration$1,
-  isFunctionDeclaration: isFunctionDeclaration$1,
-  isVariableStatement: isVariableStatement$1,
-  isInterfaceDeclaration: isInterfaceDeclaration$1,
-  isTypeAliasDeclaration: isTypeAliasDeclaration$1,
+  isFunctionDeclaration,
+  isVariableStatement,
+  isInterfaceDeclaration,
+  isTypeAliasDeclaration,
   isClassDeclaration,
   isEnumDeclaration,
   SyntaxKind
 } = tsBridge;
-function analyzeUnusedStatements(sourceFile, bindingResolver) {
+function analyzeUnusedStatements(sourceFile) {
   const statementsToRemove = /* @__PURE__ */ new Set();
   const collectUsedIdentifiers = () => {
     const used = /* @__PURE__ */ new Set();
@@ -141,19 +151,19 @@ function isExportStatement(statement) {
   return false;
 }
 function getStatementDefinedName(statement) {
-  if (isFunctionDeclaration$1(statement) && statement.name) {
+  if (isFunctionDeclaration(statement) && statement.name) {
     return statement.name.text;
   }
-  if (isVariableStatement$1(statement)) {
+  if (isVariableStatement(statement)) {
     const firstDecl = statement.declarationList.declarations[0];
     if (firstDecl && isIdentifier$1(firstDecl.name)) {
       return firstDecl.name.text;
     }
   }
-  if (isInterfaceDeclaration$1(statement) && statement.name) {
+  if (isInterfaceDeclaration(statement) && statement.name) {
     return statement.name.text;
   }
-  if (isTypeAliasDeclaration$1(statement) && statement.name) {
+  if (isTypeAliasDeclaration(statement) && statement.name) {
     return statement.name.text;
   }
   if (isClassDeclaration(statement) && statement.name) {
@@ -173,19 +183,10 @@ const {
   isPropertyAccessExpression,
   isImportDeclaration,
   isNamedImports,
-  isIdentifier,
-  isFunctionDeclaration,
-  isVariableStatement,
-  isInterfaceDeclaration,
-  isTypeAliasDeclaration
+  isIdentifier
 } = tsBridge;
 function transformJayStackBuilder(code, filePath, environment) {
-  const sourceFile = createSourceFile(
-    filePath,
-    code,
-    ScriptTarget.Latest,
-    true
-  );
+  const sourceFile = createSourceFile(filePath, code, ScriptTarget.Latest, true);
   const transformers = [mkTransformer(mkJayStackCodeSplitTransformer, { environment })];
   const printer = createPrinter();
   const result = tsBridge.transform(sourceFile, transformers);
@@ -206,11 +207,7 @@ function mkJayStackCodeSplitTransformer({
   environment
 }) {
   const bindingResolver = new SourceFileBindingResolver(sourceFile);
-  const { callsToRemove, removedVariables } = findBuilderMethodsToRemove(
-    sourceFile,
-    bindingResolver,
-    environment
-  );
+  const { callsToRemove } = findBuilderMethodsToRemove(sourceFile, bindingResolver, environment);
   const transformVisitor = (node) => {
     if (isCallExpression(node) && isPropertyAccessExpression(node.expression)) {
       const variable = bindingResolver.explain(node.expression);
@@ -222,11 +219,12 @@ function mkJayStackCodeSplitTransformer({
     }
     return visitEachChild(node, transformVisitor, context);
   };
-  let transformedSourceFile = visitEachChild(sourceFile, transformVisitor, context);
-  new SourceFileBindingResolver(transformedSourceFile);
-  const { statementsToRemove, unusedImports } = analyzeUnusedStatements(
-    transformedSourceFile
+  let transformedSourceFile = visitEachChild(
+    sourceFile,
+    transformVisitor,
+    context
   );
+  const { statementsToRemove, unusedImports } = analyzeUnusedStatements(transformedSourceFile);
   const transformedStatements = transformedSourceFile.statements.map((statement) => {
     if (statementsToRemove.has(statement)) {
       return void 0;
@@ -256,32 +254,365 @@ function filterImportDeclaration(statement, unusedImports, factory) {
       importClause,
       importClause.isTypeOnly,
       importClause.name,
-      factory.updateNamedImports(
-        importClause.namedBindings,
-        usedElements
-      )
+      factory.updateNamedImports(importClause.namedBindings, usedElements)
     ),
     statement.moduleSpecifier,
     statement.assertClause
   );
 }
-function jayStackCompiler(jayOptions = {}) {
-  return [
+const actionMetadataCache = /* @__PURE__ */ new Map();
+function clearActionMetadataCache() {
+  actionMetadataCache.clear();
+}
+function isActionImport(importSource) {
+  return importSource.includes(".actions") || importSource.includes("-actions") || importSource.includes("/actions/") || importSource.endsWith("/actions");
+}
+function extractActionsFromSource(sourceCode, filePath) {
+  const cached = actionMetadataCache.get(filePath);
+  if (cached) {
+    return cached;
+  }
+  const actions = [];
+  const sourceFile = tsBridge.createSourceFile(
+    filePath,
+    sourceCode,
+    tsBridge.ScriptTarget.Latest,
+    true
+  );
+  function visit(node) {
+    if (tsBridge.isVariableStatement(node)) {
+      const hasExport = node.modifiers?.some(
+        (m) => m.kind === tsBridge.SyntaxKind.ExportKeyword
+      );
+      if (!hasExport) {
+        tsBridge.forEachChild(node, visit);
+        return;
+      }
+      for (const decl of node.declarationList.declarations) {
+        if (!tsBridge.isIdentifier(decl.name) || !decl.initializer) {
+          continue;
+        }
+        const exportName = decl.name.text;
+        const actionMeta = extractActionFromExpression(decl.initializer);
+        if (actionMeta) {
+          actions.push({
+            ...actionMeta,
+            exportName
+          });
+        }
+      }
+    }
+    tsBridge.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  actionMetadataCache.set(filePath, actions);
+  return actions;
+}
+function extractActionFromExpression(node) {
+  let current = node;
+  let method = "POST";
+  let explicitMethod = null;
+  while (tsBridge.isCallExpression(current)) {
+    const expr = current.expression;
+    if (tsBridge.isPropertyAccessExpression(expr) && expr.name.text === "withMethod") {
+      const arg = current.arguments[0];
+      if (arg && tsBridge.isStringLiteral(arg)) {
+        explicitMethod = arg.text;
+      }
+      current = expr.expression;
+      continue;
+    }
+    if (tsBridge.isPropertyAccessExpression(expr) && ["withServices", "withCaching", "withHandler", "withTimeout"].includes(expr.name.text)) {
+      current = expr.expression;
+      continue;
+    }
+    if (tsBridge.isIdentifier(expr)) {
+      const funcName = expr.text;
+      if (funcName === "makeJayAction" || funcName === "makeJayQuery") {
+        const nameArg = current.arguments[0];
+        if (nameArg && tsBridge.isStringLiteral(nameArg)) {
+          method = funcName === "makeJayQuery" ? "GET" : "POST";
+          if (explicitMethod) {
+            method = explicitMethod;
+          }
+          return {
+            actionName: nameArg.text,
+            method
+          };
+        }
+      }
+    }
+    break;
+  }
+  return null;
+}
+async function transformActionImports(code, id, resolveActionModule) {
+  if (!code.includes("import")) {
+    return null;
+  }
+  const sourceFile = tsBridge.createSourceFile(id, code, tsBridge.ScriptTarget.Latest, true);
+  const actionImports = [];
+  for (const statement of sourceFile.statements) {
+    if (!tsBridge.isImportDeclaration(statement)) {
+      continue;
+    }
+    const moduleSpecifier = statement.moduleSpecifier;
+    if (!tsBridge.isStringLiteral(moduleSpecifier)) {
+      continue;
+    }
+    const importSource = moduleSpecifier.text;
+    if (!isActionImport(importSource)) {
+      continue;
+    }
+    const importClause = statement.importClause;
+    if (!importClause?.namedBindings || !tsBridge.isNamedImports(importClause.namedBindings)) {
+      continue;
+    }
+    const namedImports = importClause.namedBindings.elements.map(
+      (el) => el.propertyName ? el.propertyName.text : el.name.text
+    );
+    actionImports.push({
+      importDecl: statement,
+      source: importSource,
+      namedImports,
+      start: statement.getStart(),
+      end: statement.getEnd()
+    });
+  }
+  if (actionImports.length === 0) {
+    return null;
+  }
+  const replacements = [];
+  let needsCreateActionCallerImport = false;
+  for (const imp of actionImports) {
+    const resolved = await resolveActionModule(imp.source, id);
+    if (!resolved) {
+      console.warn(`[action-transform] Could not resolve action module: ${imp.source}`);
+      continue;
+    }
+    const actions = extractActionsFromSource(resolved.code, resolved.path);
+    const callerDeclarations = [];
+    for (const importName of imp.namedImports) {
+      const action = actions.find((a) => a.exportName === importName);
+      if (action) {
+        callerDeclarations.push(
+          `const ${importName} = createActionCaller('${action.actionName}', '${action.method}');`
+        );
+        needsCreateActionCallerImport = true;
+      } else {
+        console.warn(
+          `[action-transform] Export '${importName}' from ${imp.source} is not a recognized action`
+        );
+      }
+    }
+    if (callerDeclarations.length > 0) {
+      replacements.push({
+        start: imp.start,
+        end: imp.end,
+        replacement: callerDeclarations.join("\n")
+      });
+    }
+  }
+  if (replacements.length === 0) {
+    return null;
+  }
+  let result = code;
+  for (const rep of replacements.sort((a, b) => b.start - a.start)) {
+    result = result.slice(0, rep.start) + rep.replacement + result.slice(rep.end);
+  }
+  if (needsCreateActionCallerImport) {
+    const importStatement = `import { createActionCaller } from '@jay-framework/stack-client-runtime';
+`;
+    result = importStatement + result;
+  }
+  return { code: result };
+}
+const SERVER_ONLY_MODULES = /* @__PURE__ */ new Set([
+  "module",
+  // createRequire
+  "fs",
+  "path",
+  "node:fs",
+  "node:path",
+  "node:module",
+  "child_process",
+  "node:child_process",
+  "crypto",
+  "node:crypto"
+]);
+const SERVER_ONLY_PACKAGE_PATTERNS = [
+  "@jay-framework/compiler-shared",
+  "@jay-framework/stack-server-runtime",
+  "yaml"
+  // Often used in server config
+];
+function createImportChainTracker(options = {}) {
+  const {
+    verbose = false,
+    additionalServerModules = [],
+    additionalServerPatterns = []
+  } = options;
+  const importChain = /* @__PURE__ */ new Map();
+  const detectedServerModules = /* @__PURE__ */ new Set();
+  const serverOnlyModules = /* @__PURE__ */ new Set([...SERVER_ONLY_MODULES, ...additionalServerModules]);
+  const serverOnlyPatterns = [...SERVER_ONLY_PACKAGE_PATTERNS, ...additionalServerPatterns];
+  function isServerOnlyModule(id) {
+    if (serverOnlyModules.has(id)) {
+      return true;
+    }
+    for (const pattern of serverOnlyPatterns) {
+      if (id.includes(pattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function buildImportChain(moduleId) {
+    const chain = [moduleId];
+    let current = moduleId;
+    for (let i = 0; i < 100; i++) {
+      const importer = importChain.get(current);
+      if (!importer)
+        break;
+      chain.push(importer);
+      current = importer;
+    }
+    return chain.reverse();
+  }
+  function formatChain(chain) {
+    return chain.map((id, idx) => {
+      const indent = "  ".repeat(idx);
+      const shortId = shortenPath(id);
+      return `${indent}${idx === 0 ? "" : "↳ "}${shortId}`;
+    }).join("\n");
+  }
+  function shortenPath(id) {
+    if (id.includes("node_modules")) {
+      const parts = id.split("node_modules/");
+      return parts[parts.length - 1];
+    }
+    const cwd = process.cwd();
+    if (id.startsWith(cwd)) {
+      return id.slice(cwd.length + 1);
+    }
+    return id;
+  }
+  return {
+    name: "jay-stack:import-chain-tracker",
+    enforce: "pre",
+    buildStart() {
+      importChain.clear();
+      detectedServerModules.clear();
+      if (verbose) {
+        console.log("[import-chain-tracker] Build started, tracking imports...");
+      }
+    },
+    resolveId(source, importer, options2) {
+      if (options2?.ssr) {
+        return null;
+      }
+      if (source.startsWith("\0")) {
+        return null;
+      }
+      if (importer) {
+        if (verbose) {
+          console.log(
+            `[import-chain-tracker] ${shortenPath(importer)} imports ${source}`
+          );
+        }
+      }
+      return null;
+    },
+    load(id) {
+      return null;
+    },
+    transform(code, id, options2) {
+      if (options2?.ssr) {
+        return null;
+      }
+      if (isServerOnlyModule(id)) {
+        detectedServerModules.add(id);
+        const chain = buildImportChain(id);
+        console.error(
+          `
+[import-chain-tracker] ⚠️  Server-only module detected in client build!`
+        );
+        console.error(`Module: ${shortenPath(id)}`);
+        console.error(`Import chain:`);
+        console.error(formatChain(chain));
+        console.error("");
+      }
+      const importRegex = /import\s+(?:(?:\{[^}]*\}|[^{}\s,]+)\s+from\s+)?['"]([^'"]+)['"]/g;
+      let match;
+      while ((match = importRegex.exec(code)) !== null) {
+        const importedModule = match[1];
+        importChain.set(importedModule, id);
+        if (isServerOnlyModule(importedModule)) {
+          if (!detectedServerModules.has(importedModule)) {
+            detectedServerModules.add(importedModule);
+            console.error(
+              `
+[import-chain-tracker] ⚠️  Server-only import detected in client build!`
+            );
+            console.error(`Module "${importedModule}" imported by: ${shortenPath(id)}`);
+            const chain = buildImportChain(id);
+            chain.push(importedModule);
+            console.error(`Import chain:`);
+            console.error(formatChain(chain));
+            console.error("");
+          }
+        }
+      }
+      return null;
+    },
+    buildEnd() {
+      if (detectedServerModules.size > 0) {
+        console.warn(
+          `
+[import-chain-tracker] ⚠️  ${detectedServerModules.size} server-only module(s) detected during transform:`
+        );
+        for (const mod of detectedServerModules) {
+          console.warn(`  - ${mod}`);
+        }
+        console.warn(
+          "\nNote: These may be stripped by the code-split transform if only used in .withServer()."
+        );
+        console.warn(
+          'If build fails with "not exported" errors, check the import chains above.\n'
+        );
+      } else if (verbose) {
+        console.log(
+          "[import-chain-tracker] ✅ No server-only modules detected in client build"
+        );
+      }
+    }
+  };
+}
+function jayStackCompiler(options = {}) {
+  const { trackImports, ...jayOptions } = options;
+  const moduleCache = /* @__PURE__ */ new Map();
+  const shouldTrackImports = trackImports || process.env.DEBUG_IMPORTS === "1";
+  const trackerOptions = typeof trackImports === "object" ? trackImports : { verbose: process.env.DEBUG_IMPORTS === "1" };
+  const plugins = [];
+  if (shouldTrackImports) {
+    plugins.push(createImportChainTracker(trackerOptions));
+  }
+  plugins.push(
     // First: Jay Stack code splitting transformation
     {
       name: "jay-stack:code-split",
       enforce: "pre",
       // Run before jay:runtime
-      transform(code, id) {
-        const isClientBuild = id.includes("?jay-client");
-        const isServerBuild = id.includes("?jay-server");
-        if (!isClientBuild && !isServerBuild) {
+      transform(code, id, options2) {
+        if (!id.endsWith(".ts") && !id.includes(".ts?")) {
           return null;
         }
-        const environment = isClientBuild ? "client" : "server";
-        if (!id.endsWith(".ts") && !id.includes(".ts?")) {
+        const hasComponent = code.includes("makeJayStackComponent");
+        const hasInit = code.includes("makeJayInit");
+        if (!hasComponent && !hasInit) {
           return null;
         }
+        const environment = options2?.ssr ? "server" : "client";
         try {
           return transformJayStackBuilder(code, id, environment);
         } catch (error) {
@@ -290,11 +621,92 @@ function jayStackCompiler(jayOptions = {}) {
         }
       }
     },
-    // Second: Jay runtime compilation (existing plugin)
+    // Second: Action import transformation (client builds only)
+    // Uses resolveId + load to replace action modules with virtual modules
+    // containing createActionCaller calls BEFORE bundling happens.
+    (() => {
+      let isSSRBuild = false;
+      return {
+        name: "jay-stack:action-transform",
+        enforce: "pre",
+        // Track SSR mode from config
+        configResolved(config) {
+          isSSRBuild = config.build?.ssr ?? false;
+        },
+        buildStart() {
+          clearActionMetadataCache();
+          moduleCache.clear();
+        },
+        async resolveId(source, importer, options2) {
+          if (options2?.ssr || isSSRBuild) {
+            return null;
+          }
+          if (!isActionImport(source)) {
+            return null;
+          }
+          if (!source.startsWith(".") || !importer) {
+            return null;
+          }
+          const importerDir = path.dirname(importer);
+          let resolvedPath = path.resolve(importerDir, source);
+          if (!resolvedPath.endsWith(".ts") && !resolvedPath.endsWith(".js")) {
+            if (fs.existsSync(resolvedPath + ".ts")) {
+              resolvedPath += ".ts";
+            } else if (fs.existsSync(resolvedPath + ".js")) {
+              resolvedPath += ".js";
+            } else {
+              return null;
+            }
+          }
+          return `\0jay-action:${resolvedPath}`;
+        },
+        async load(id) {
+          if (!id.startsWith("\0jay-action:")) {
+            return null;
+          }
+          const actualPath = id.slice("\0jay-action:".length);
+          let code;
+          try {
+            code = await fs.promises.readFile(actualPath, "utf-8");
+          } catch (err) {
+            console.error(`[action-transform] Could not read ${actualPath}:`, err);
+            return null;
+          }
+          const actions = extractActionsFromSource(code, actualPath);
+          if (actions.length === 0) {
+            console.warn(`[action-transform] No actions found in ${actualPath}`);
+            return null;
+          }
+          const lines = [
+            `import { createActionCaller } from '@jay-framework/stack-client-runtime';`,
+            ""
+          ];
+          for (const action of actions) {
+            lines.push(
+              `export const ${action.exportName} = createActionCaller('${action.actionName}', '${action.method}');`
+            );
+          }
+          if (code.includes("ActionError")) {
+            lines.push(
+              `export { ActionError } from '@jay-framework/stack-client-runtime';`
+            );
+          }
+          const result = lines.join("\n");
+          return result;
+        }
+      };
+    })(),
+    // Third: Jay runtime compilation (existing plugin)
     jayRuntime(jayOptions)
-  ];
+  );
+  return plugins;
 }
 export {
+  clearActionMetadataCache,
+  createImportChainTracker,
+  extractActionsFromSource,
+  isActionImport,
   jayStackCompiler,
+  transformActionImports,
   transformJayStackBuilder
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/compiler-jay-stack",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "type": "module",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -27,16 +27,17 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@jay-framework/compiler": "^0.9.0",
-    "@jay-framework/typescript-bridge": "^0.4.0",
-    "@jay-framework/vite-plugin": "^0.9.0",
+    "@jay-framework/compiler": "^0.10.0",
+    "@jay-framework/compiler-shared": "^0.10.0",
+    "@jay-framework/typescript-bridge": "^0.5.0",
+    "@jay-framework/vite-plugin": "^0.10.0",
+    "typescript": "^5.3.3",
     "vite": "^5.0.11"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.9.0",
+    "@jay-framework/dev-environment": "^0.10.0",
     "rimraf": "^5.0.5",
     "tsup": "^8.0.1",
-    "typescript": "^5.3.3",
     "vitest": "^1.2.1"
   }
 }