zero-com 1.6.4 → 1.6.6

package/README.md

@@ -7,6 +7,7 @@ The 0 bytes utility for transparently communicating client and server in full-st
 - [Usage](#usage)
 - [Transport layer](#transport-layer)
 - [Context](#context)
+- [Server-to-Server Calls](#server-to-server-calls)
 - [Plugin options](#plugin-options)
 - [Complete Example](#complete-example)
 
@@ -57,7 +58,7 @@ Server side
 // server/phones.ts
 import { func } from 'zero-com';
 
-export const getPhones = func(async () => { 
+export const getPhones = func(async () => {
   // ...
 })
 ```
@@ -100,8 +101,8 @@ On the server-side, you need to create a handler that receives messages from the
 // server/api.js
 import { handle } from 'zero-com';
 
-const someCustomHandler = async (message) => {
-  return await handle(message.funcId, null, message.params);
+const someCustomHandler = async (message, ctx) => {
+  return await handle(message.funcId, ctx, message.params);
 };
 
 // Example of how to use the handler with an Express server
@@ -112,7 +113,8 @@ app.use(express.json());
 
 app.post('/api', async (req, res) => {
   try {
-    const result = await someCustomHandler(req.body);
+    const ctx = { req, res };
+    const result = await someCustomHandler(req.body, ctx);
     res.json(result);
   } catch (error) {
     res.status(500).json({ error: error.message });
@@ -126,42 +128,90 @@ app.listen(8000, () => {
 
 ## Context
 
-Often you want to pass a context-related object to the server functions to have access to data like the request, response, session, etc. Zero-com provides a simple way to do this.
+Often you want to access context-related data in your server functions, such as the request, response, session, etc. Zero-com provides a simple way to do this using the `context()` function.
 
-### Passing Context to Server Functions
+### Accessing Context in Server Functions
 
-To pass context to a server function, you need to wrap the function in `func` and type the first parameter as `context`. The plugin detects this type and handles it accordingly.
+To access context in a server function, call the `context<T>()` function inside your function body. The context is automatically available when the function is called via `handle()`.
 
 ```typescript
 // server/api/phones.ts
 import { func, context } from 'zero-com';
 
 type MyContext = {
-  request: any
+  req: any;
+  res: any;
+  userId: string;
 }
 
-export const getPhones = func(async (ctx: context<MyContext>, name: string) => {
-  // ctx is the context object passed from the server
-  console.log(ctx.request.headers);
+export const getPhones = func(async (name: string) => {
+  // Get the context inside the function
+  const ctx = context<MyContext>();
+
+  console.log('User:', ctx.userId);
+  console.log('Headers:', ctx.req.headers);
+
   // ... your code
 });
 ```
 
 ### Providing Context on the Server
 
-You can pass the context to `handle` when you execute the server function.
+Pass the context as the second argument to `handle()`. The context will be available to the function and any nested server function calls.
 
 ```javascript
 // server/api.js
 import { handle } from 'zero-com';
 
-const myHandler = (request, response, message) => {
-  const ctx = { request, response };
-  // pass context on exec
-  return handle(message.funcId, ctx, message.params);
-};
+app.post('/api', async (req, res) => {
+  const { funcId, params } = req.body;
+
+  // Create context with request data
+  const ctx = {
+    req,
+    res,
+    userId: req.headers['x-user-id']
+  };
+
+  // Pass context to handle - it will be available via context()
+  const result = await handle(funcId, ctx, params);
+  res.json(result);
+});
+```
+
+## Server-to-Server Calls
+
+When one server function calls another server function, the call bypasses the transport layer and executes directly. Context is automatically propagated to nested calls.
+
+```typescript
+// server/api/user.ts
+import { func, context } from 'zero-com';
+
+export const getFirstName = func(async () => {
+  const ctx = context<{ userId: string }>();
+  // ... fetch first name from database
+  return 'John';
+});
+
+// server/api/profile.ts
+import { func, context } from 'zero-com';
+import { getFirstName } from './user';
+
+export const getFullName = func(async (lastName: string) => {
+  // This calls getFirstName directly (no transport layer)
+  // Context is automatically propagated
+  const firstName = await getFirstName();
+  return `${firstName} ${lastName}`;
+});
 ```
 
+When `getFullName` is called from the client:
+1. The call goes through the transport layer to the server
+2. `handle()` sets up the context
+3. `getFullName` executes and calls `getFirstName`
+4. `getFirstName` executes directly (no transport) with the same context
+5. Both functions can access `context()` with the same data
+
 ## Plugin options
 
 | Option      | Type      | Description                                                                 |
@@ -225,11 +275,15 @@ call(async (funcId, params) => {
 import { func, context } from 'zero-com';
 
 type Context = {
-  req: any,
-  res: any
+  req: any;
+  res: any;
 }
 
-export const getPhones = func(async (ctx: context<Context>, name: string) => {
+export const getPhones = func(async (name: string) => {
+  // Access context when needed
+  const ctx = context<Context>();
+  console.log('Request from:', ctx.req.ip);
+
   // In a real application, you would fetch this from a database
   const allPhones = [
     { name: 'iPhone 13', brand: 'Apple' },

package/lib/common.d.ts

@@ -1,4 +1,10 @@
+import type { SourceMap } from 'magic-string';
 import { CallExpression, Project, SourceFile } from 'ts-morph';
+export type Replacement = {
+    start: number;
+    end: number;
+    content: string;
+};
 export type Options = {
     development?: boolean;
 };
@@ -6,15 +12,14 @@ export type ServerFuncInfo = {
     funcId: string;
     filePath: string;
     exportName: string;
-    requireContext: boolean;
 };
 export type ServerFuncRegistry = Map<string, Map<string, ServerFuncInfo>>;
 export declare const ZERO_COM_CLIENT_CALL = "ZERO_COM_CLIENT_CALL";
 export declare const ZERO_COM_SERVER_REGISTRY = "ZERO_COM_SERVER_REGISTRY";
+export declare const ZERO_COM_CONTEXT_STORAGE = "ZERO_COM_CONTEXT_STORAGE";
 export declare const SERVER_FUNCTION_WRAPPER_NAME = "func";
 export declare const HANDLE_NAME = "handle";
 export declare const CALL_NAME = "call";
-export declare const CONTEXT_TYPE_NAME = "context";
 export declare const LIBRARY_NAME = "zero-com";
 export declare const FILE_EXTENSIONS: string[];
 export declare const formatFuncIdName: (funcName: string, filePath: string, line: number) => string;
@@ -28,15 +33,23 @@ export declare const resolveFilePath: (basePath: string) => string;
 export declare const createProject: () => Project;
 export declare const buildRegistry: (contextDir: string, registry: ServerFuncRegistry) => void;
 export declare const getImportedServerFunctions: (sourceFile: SourceFile, registry: ServerFuncRegistry) => Map<string, ServerFuncInfo>;
-export declare const transformCallSites: (sourceFile: SourceFile, importedFuncs: Map<string, ServerFuncInfo>) => boolean;
-export declare const transformHandleCalls: (sourceFile: SourceFile) => boolean;
-export declare const transformSendCalls: (sourceFile: SourceFile) => boolean;
-export declare const transformFuncCalls: (sourceFile: SourceFile) => boolean;
+export declare const collectCallSiteReplacements: (sourceFile: SourceFile, importedFuncs: Map<string, ServerFuncInfo>) => Replacement[];
+export declare const collectHandleCallReplacements: (sourceFile: SourceFile) => Replacement[];
+export declare const collectSendCallReplacements: (sourceFile: SourceFile) => Replacement[];
+export declare const collectFuncCallReplacements: (sourceFile: SourceFile) => Replacement[];
+export declare const applyReplacementsWithMap: (source: string, replacements: Replacement[], filePath: string) => {
+    code: string;
+    map: SourceMap;
+};
 export declare const appendRegistryCode: (sourceFile: SourceFile, fileRegistry: Map<string, ServerFuncInfo>) => string;
 export type TransformResult = {
     content: string;
     transformed: boolean;
+    map?: SourceMap;
+};
+export type TransformOptions = {
+    development?: boolean;
 };
-export declare const transformSourceFile: (filePath: string, content: string, registry: ServerFuncRegistry) => TransformResult;
+export declare const transformSourceFile: (filePath: string, content: string, registry: ServerFuncRegistry, options?: TransformOptions) => TransformResult;
 export declare const emitToJs: (filePath: string, content: string) => string;
 export declare const applyReplacements: (code: string, compilationId: string) => string;

package/lib/common.js

@@ -3,17 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyReplacements = exports.emitToJs = exports.transformSourceFile = exports.appendRegistryCode = exports.transformFuncCalls = exports.transformSendCalls = exports.transformHandleCalls = exports.transformCallSites = exports.getImportedServerFunctions = exports.buildRegistry = exports.createProject = exports.resolveFilePath = exports.isFromLibrary = exports.getReplacements = exports.generateCompilationId = exports.formatFuncIdName = exports.FILE_EXTENSIONS = exports.LIBRARY_NAME = exports.CONTEXT_TYPE_NAME = exports.CALL_NAME = exports.HANDLE_NAME = exports.SERVER_FUNCTION_WRAPPER_NAME = exports.ZERO_COM_SERVER_REGISTRY = exports.ZERO_COM_CLIENT_CALL = void 0;
+exports.applyReplacements = exports.emitToJs = exports.transformSourceFile = exports.appendRegistryCode = exports.applyReplacementsWithMap = exports.collectFuncCallReplacements = exports.collectSendCallReplacements = exports.collectHandleCallReplacements = exports.collectCallSiteReplacements = exports.getImportedServerFunctions = exports.buildRegistry = exports.createProject = exports.resolveFilePath = exports.isFromLibrary = exports.getReplacements = exports.generateCompilationId = exports.formatFuncIdName = exports.FILE_EXTENSIONS = exports.LIBRARY_NAME = exports.CALL_NAME = exports.HANDLE_NAME = exports.SERVER_FUNCTION_WRAPPER_NAME = exports.ZERO_COM_CONTEXT_STORAGE = exports.ZERO_COM_SERVER_REGISTRY = exports.ZERO_COM_CLIENT_CALL = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const magic_string_1 = __importDefault(require("magic-string"));
 const ts_morph_1 = require("ts-morph");
 // Constants
 exports.ZERO_COM_CLIENT_CALL = 'ZERO_COM_CLIENT_CALL';
 exports.ZERO_COM_SERVER_REGISTRY = 'ZERO_COM_SERVER_REGISTRY';
+exports.ZERO_COM_CONTEXT_STORAGE = 'ZERO_COM_CONTEXT_STORAGE';
 exports.SERVER_FUNCTION_WRAPPER_NAME = 'func';
 exports.HANDLE_NAME = 'handle';
 exports.CALL_NAME = 'call';
-exports.CONTEXT_TYPE_NAME = 'context';
 exports.LIBRARY_NAME = 'zero-com';
 exports.FILE_EXTENSIONS = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs'];
 const formatFuncIdName = (funcName, filePath, line) => {
@@ -24,7 +25,8 @@ const generateCompilationId = () => String(Math.floor(Math.random() * 1000000));
 exports.generateCompilationId = generateCompilationId;
 const getReplacements = (compilationId) => [
     { target: exports.ZERO_COM_CLIENT_CALL, replacement: `__ZERO_COM_CLIENT_CALL_${compilationId}` },
-    { target: exports.ZERO_COM_SERVER_REGISTRY, replacement: `__ZERO_COM_SERVER_REGISTRY_${compilationId}` }
+    { target: exports.ZERO_COM_SERVER_REGISTRY, replacement: `__ZERO_COM_SERVER_REGISTRY_${compilationId}` },
+    { target: exports.ZERO_COM_CONTEXT_STORAGE, replacement: `__ZERO_COM_CONTEXT_STORAGE_${compilationId}` }
 ];
 exports.getReplacements = getReplacements;
 // Utilities
@@ -97,7 +99,6 @@ const buildRegistry = (contextDir, registry) => {
 };
 exports.buildRegistry = buildRegistry;
 const scanFileForServerFunctions = (filePath, contextDir, registry) => {
-    var _a;
     const sourceFile = (0, exports.createProject)().createSourceFile(filePath, fs_1.default.readFileSync(filePath, 'utf8'), { overwrite: true });
     const fileRegistry = new Map();
     for (const decl of sourceFile.getVariableDeclarations()) {
@@ -115,14 +116,11 @@ const scanFileForServerFunctions = (filePath, contextDir, registry) => {
         const args = callExpr.getArguments();
         if (args.length !== 1 || args[0].getKind() !== ts_morph_1.SyntaxKind.ArrowFunction)
             continue;
-        const params = args[0].getParameters();
-        const requireContext = params.length > 0 && ((_a = params[0].getTypeNode()) === null || _a === void 0 ? void 0 : _a.getText().startsWith(exports.CONTEXT_TYPE_NAME)) || false;
         const exportName = decl.getName();
         fileRegistry.set(exportName, {
             funcId: (0, exports.formatFuncIdName)(exportName, path_1.default.relative(contextDir, filePath), decl.getStartLineNumber()),
             filePath,
             exportName,
-            requireContext,
         });
     }
     if (fileRegistry.size > 0)
@@ -153,11 +151,11 @@ const getImportedServerFunctions = (sourceFile, registry) => {
     return importedFuncs;
 };
 exports.getImportedServerFunctions = getImportedServerFunctions;
-// Transformations
-const transformCallSites = (sourceFile, importedFuncs) => {
+// Transformations - collect replacements instead of modifying AST
+const collectCallSiteReplacements = (sourceFile, importedFuncs) => {
     if (importedFuncs.size === 0)
-        return false;
-    let modified = false;
+        return [];
+    const replacements = [];
     sourceFile.forEachDescendant((node) => {
         if (node.getKind() !== ts_morph_1.SyntaxKind.CallExpression)
             return;
@@ -167,14 +165,17 @@ const transformCallSites = (sourceFile, importedFuncs) => {
         if (!funcInfo)
             return;
         const args = callExpr.getArguments().map(a => a.getText()).join(', ');
-        callExpr.replaceWithText(`globalThis.${exports.ZERO_COM_CLIENT_CALL}('${funcInfo.funcId}', [${args}])`);
-        modified = true;
+        replacements.push({
+            start: callExpr.getStart(),
+            end: callExpr.getEnd(),
+            content: `globalThis.${exports.ZERO_COM_CLIENT_CALL}('${funcInfo.funcId}', [${args}])`
+        });
     });
-    return modified;
+    return replacements;
 };
-exports.transformCallSites = transformCallSites;
-const transformHandleCalls = (sourceFile) => {
-    let modified = false;
+exports.collectCallSiteReplacements = collectCallSiteReplacements;
+const collectHandleCallReplacements = (sourceFile) => {
+    const replacements = [];
     sourceFile.forEachDescendant((node) => {
         if (node.getKind() !== ts_morph_1.SyntaxKind.CallExpression)
             return;
@@ -184,18 +185,21 @@ const transformHandleCalls = (sourceFile) => {
         const args = callExpr.getArguments();
         if (args.length < 3)
             return;
-        // Inline the logic directly using a named function for better stack traces.
         const funcId = args[0].getText();
         const ctx = args[1].getText();
         const argsArray = args[2].getText();
-        callExpr.replaceWithText(`(function handle(__fn, __ctx, __args) { return __fn.requireContext ? __fn(__ctx, ...__args) : __fn(...__args); })(globalThis.${exports.ZERO_COM_SERVER_REGISTRY}[${funcId}], ${ctx}, ${argsArray})`);
-        modified = true;
+        // Use contextStorage.run() to make context available via context() calls
+        replacements.push({
+            start: callExpr.getStart(),
+            end: callExpr.getEnd(),
+            content: `globalThis.${exports.ZERO_COM_CONTEXT_STORAGE}.run(${ctx}, () => globalThis.${exports.ZERO_COM_SERVER_REGISTRY}[${funcId}](...${argsArray}))`
+        });
     });
-    return modified;
+    return replacements;
 };
-exports.transformHandleCalls = transformHandleCalls;
-const transformSendCalls = (sourceFile) => {
-    let modified = false;
+exports.collectHandleCallReplacements = collectHandleCallReplacements;
+const collectSendCallReplacements = (sourceFile) => {
+    const replacements = [];
     sourceFile.forEachDescendant((node) => {
         if (node.getKind() !== ts_morph_1.SyntaxKind.CallExpression)
             return;
@@ -205,18 +209,21 @@ const transformSendCalls = (sourceFile) => {
         const args = callExpr.getArguments();
         if (args.length < 1)
             return;
-        callExpr.replaceWithText(`globalThis.${exports.ZERO_COM_CLIENT_CALL} = ${args[0].getText()}`);
-        modified = true;
+        replacements.push({
+            start: callExpr.getStart(),
+            end: callExpr.getEnd(),
+            content: `globalThis.${exports.ZERO_COM_CLIENT_CALL} = ${args[0].getText()}`
+        });
     });
-    return modified;
+    return replacements;
 };
-exports.transformSendCalls = transformSendCalls;
-// Transform func(fn) calls to just fn.
+exports.collectSendCallReplacements = collectSendCallReplacements;
+// Collect func(fn) replacements to just fn.
 // The func() wrapper is only needed for type-level transformation (RemoveContextParam).
 // At runtime, we just need the raw function. The registration code (appendRegistryCode)
 // will set requireContext on the function based on compile-time analysis.
-const transformFuncCalls = (sourceFile) => {
-    let modified = false;
+const collectFuncCallReplacements = (sourceFile) => {
+    const replacements = [];
     sourceFile.forEachDescendant((node) => {
         if (node.getKind() !== ts_morph_1.SyntaxKind.CallExpression)
             return;
@@ -227,27 +234,41 @@ const transformFuncCalls = (sourceFile) => {
         if (args.length !== 1)
             return;
         // Replace func(fn) with just fn
-        callExpr.replaceWithText(args[0].getText());
-        modified = true;
+        replacements.push({
+            start: callExpr.getStart(),
+            end: callExpr.getEnd(),
+            content: args[0].getText()
+        });
     });
-    return modified;
+    return replacements;
 };
-exports.transformFuncCalls = transformFuncCalls;
+exports.collectFuncCallReplacements = collectFuncCallReplacements;
+// Apply collected replacements using MagicString for sourcemap support
+const applyReplacementsWithMap = (source, replacements, filePath) => {
+    const s = new magic_string_1.default(source);
+    // Sort replacements by start position descending to preserve positions
+    const sorted = [...replacements].sort((a, b) => b.start - a.start);
+    for (const { start, end, content } of sorted) {
+        s.overwrite(start, end, content);
+    }
+    return {
+        code: s.toString(),
+        map: s.generateMap({ source: filePath, includeContent: true, hires: true })
+    };
+};
+exports.applyReplacementsWithMap = applyReplacementsWithMap;
 const appendRegistryCode = (sourceFile, fileRegistry) => {
-    // Generate registration code for each server function.
-    // We set requireContext based on compile-time analysis of the function's first parameter type.
-    // If the first param is context<T>, requireContext = true, otherwise false.
-    // This allows execFunc() at runtime to know whether to inject the context as the first argument.
+    // Generate registration code for each server function
     const registrations = Array.from(fileRegistry.values())
-        .map(info => `globalThis.${exports.ZERO_COM_SERVER_REGISTRY}['${info.funcId}'] = ${info.exportName};\n` +
-        `${info.exportName}.requireContext = ${info.requireContext};`)
+        .map(info => `globalThis.${exports.ZERO_COM_SERVER_REGISTRY}['${info.funcId}'] = ${info.exportName};`)
         .join('\n');
     return `${sourceFile.getFullText()}
 if (!globalThis.${exports.ZERO_COM_SERVER_REGISTRY}) globalThis.${exports.ZERO_COM_SERVER_REGISTRY} = Object.create(null);
 ${registrations}`;
 };
 exports.appendRegistryCode = appendRegistryCode;
-const transformSourceFile = (filePath, content, registry) => {
+const transformSourceFile = (filePath, content, registry, options = {}) => {
+    const { development = true } = options;
     const project = (0, exports.createProject)();
     const sourceFile = project.createSourceFile(filePath, content, { overwrite: true });
     const fileRegistry = registry.get(filePath);
@@ -257,17 +278,34 @@ const transformSourceFile = (filePath, content, registry) => {
     if (isServerFunctionFile) {
         fileRegistry.forEach((_, name) => importedFuncs.delete(name));
     }
-    const callsTransformed = (0, exports.transformCallSites)(sourceFile, importedFuncs);
-    const handleTransformed = (0, exports.transformHandleCalls)(sourceFile);
-    const sendTransformed = (0, exports.transformSendCalls)(sourceFile);
-    // Transform func() calls in files that define server functions.
-    // This strips the func() wrapper since it's only needed for types.
+    // Collect all replacements
+    const replacements = [];
+    // Always collect client call site replacements (needed in both dev and prod)
+    replacements.push(...(0, exports.collectCallSiteReplacements)(sourceFile, importedFuncs));
+    // In production mode, collect handle(), call(), and func() replacements.
+    // In development mode, these work at runtime via ZERO_COM_DEV_MODE flag.
+    if (!development) {
+        replacements.push(...(0, exports.collectHandleCallReplacements)(sourceFile));
+        replacements.push(...(0, exports.collectSendCallReplacements)(sourceFile));
+    }
+    // Handle server function files
     if (isServerFunctionFile) {
-        (0, exports.transformFuncCalls)(sourceFile);
+        // In production mode, strip func() wrappers
+        if (!development) {
+            replacements.push(...(0, exports.collectFuncCallReplacements)(sourceFile));
+        }
+        // Apply replacements and append registry code
+        if (replacements.length > 0) {
+            const { code, map } = (0, exports.applyReplacementsWithMap)(content, replacements, filePath);
+            // Create a new source file from the transformed code to append registry
+            const transformedSourceFile = project.createSourceFile(filePath + '.transformed', code, { overwrite: true });
+            return { content: (0, exports.appendRegistryCode)(transformedSourceFile, fileRegistry), transformed: true, map };
+        }
         return { content: (0, exports.appendRegistryCode)(sourceFile, fileRegistry), transformed: true };
     }
-    if (callsTransformed || handleTransformed || sendTransformed) {
-        return { content: sourceFile.getFullText(), transformed: true };
+    if (replacements.length > 0) {
+        const { code, map } = (0, exports.applyReplacementsWithMap)(content, replacements, filePath);
+        return { content: code, transformed: true, map };
     }
     return { content, transformed: false };
 };

package/lib/rollup.js

@@ -42,15 +42,16 @@ function zeroComRollupPlugin(options = {}) {
             });
         },
         load(id) {
-            var _a, _b;
+            var _a, _b, _c;
             if (!((_b = (_a = this.getModuleInfo(id)) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.needsTransform) || !fs_1.default.existsSync(id))
                 return null;
             const content = fs_1.default.readFileSync(id, 'utf8');
-            const result = (0, common_1.transformSourceFile)(id, content, registry);
+            const result = (0, common_1.transformSourceFile)(id, content, registry, { development });
             if (!result.transformed)
                 return null;
             console.log(`[ZeroComRollupPlugin] Transformed: ${path_1.default.relative(process.cwd(), id)}`);
-            return (0, common_1.emitToJs)(id, result.content);
+            const code = (0, common_1.emitToJs)(id, result.content);
+            return { code, map: (_c = result.map) !== null && _c !== void 0 ? _c : null };
         },
         renderChunk(code) {
             if (development)

package/lib/runtime.d.ts

@@ -2,14 +2,13 @@ declare global {
     var ZERO_COM_SERVER_REGISTRY: {
         [funcId: string]: (...args: any[]) => any;
     };
-    var ZERO_COM_CLIENT_CALL: (funcId: string, args: any[]) => Promise<any>;
+    var ZERO_COM_CLIENT_CALL: (funcId: string, args: any[]) => any;
+    var ZERO_COM_CONTEXT_STORAGE: {
+        run: <T>(ctx: any, fn: () => T) => T;
+        getStore: () => any;
+    } | undefined;
 }
-declare const contextBrand: unique symbol;
-export type context<T = unknown> = T & {
-    readonly [contextBrand]: never;
-};
-type RemoveContextParam<F> = F extends (ctx: infer C, ...args: infer A) => infer R ? C extends context<unknown> ? (...args: A) => R : F : F;
-export declare function func<F extends (...args: any[]) => any>(fn: F): RemoveContextParam<F>;
-export declare const handle: (_funcId: string, _ctx: any, _args: any[]) => any;
-export declare const call: (_fn: (funcId: string, args: any[]) => Promise<any>) => void;
-export {};
+export declare function context<T = unknown>(): T;
+export declare function func<F extends (...args: any[]) => any>(fn: F): F;
+export declare const handle: (funcId: string, ctx: any, args: any[]) => any;
+export declare const call: (fn: (funcId: string, args: any[]) => any) => void;

package/lib/runtime.js

@@ -1,21 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.call = exports.handle = void 0;
+exports.context = context;
 exports.func = func;
-// Implementation
-// User-facing function - transformed by plugin to just the inner function.
-// The plugin also appends code to register the function and set requireContext based on
-// compile-time analysis of whether the first parameter is context<T>.
-function func(_fn) {
-    throw new Error('func() was not transformed. Ensure the zero-com plugin is configured.');
+// Context storage - only available on server (Node.js)
+// Lazily initialized to avoid importing async_hooks on client
+function getContextStorage() {
+    if (!globalThis.ZERO_COM_CONTEXT_STORAGE) {
+        try {
+            // Dynamic import to avoid bundling async_hooks for browser
+            const { AsyncLocalStorage } = require('async_hooks');
+            globalThis.ZERO_COM_CONTEXT_STORAGE = new AsyncLocalStorage();
+        }
+        catch (_a) {
+            // Browser environment - context storage not available
+            globalThis.ZERO_COM_CONTEXT_STORAGE = undefined;
+        }
+    }
+    return globalThis.ZERO_COM_CONTEXT_STORAGE;
 }
-// User-facing function - transformed by plugin to inline code that checks requireContext and calls the function
-const handle = (_funcId, _ctx, _args) => {
-    throw new Error('handle() was not transformed. Ensure the zero-com plugin is configured.');
+// Get the current context - call this inside server functions
+function context() {
+    const storage = getContextStorage();
+    if (!storage) {
+        throw new Error('context() is only available on the server');
+    }
+    const ctx = storage.getStore();
+    if (ctx === undefined) {
+        throw new Error('context() called outside of a server function');
+    }
+    return ctx;
+}
+// Default server-side implementation: call directly from registry
+// This enables server functions to call other server functions without transport
+if (typeof globalThis.ZERO_COM_CLIENT_CALL === 'undefined') {
+    globalThis.ZERO_COM_CLIENT_CALL = (funcId, args) => {
+        var _a;
+        const storage = getContextStorage();
+        if (!storage) {
+            throw new Error('Server function called on client without transport configured. Call call() first.');
+        }
+        const ctx = storage.getStore();
+        if (ctx === undefined) {
+            throw new Error('Server function called outside of request context');
+        }
+        const fn = (_a = globalThis.ZERO_COM_SERVER_REGISTRY) === null || _a === void 0 ? void 0 : _a[funcId];
+        if (!fn)
+            throw new Error(`Function not found: ${funcId}`);
+        return fn(...args);
+    };
+}
+// func() just returns the function as-is
+// In production mode: transformed by plugin to just the inner function
+function func(fn) {
+    return fn;
+}
+// handle() stores context in AsyncLocalStorage and calls the function
+// In production mode: transformed by plugin to inline code
+const handle = (funcId, ctx, args) => {
+    var _a;
+    const fn = (_a = globalThis.ZERO_COM_SERVER_REGISTRY) === null || _a === void 0 ? void 0 : _a[funcId];
+    if (!fn) {
+        throw new Error(`Function not found in registry: ${funcId}`);
+    }
+    const storage = getContextStorage();
+    if (!storage) {
+        throw new Error('handle() is only available on the server');
+    }
+    return storage.run(ctx, () => fn(...args));
 };
 exports.handle = handle;
-// User-facing function - transformed by plugin to globalThis.ZERO_COM_CLIENT_CALL = fn
-const call = (_fn) => {
-    throw new Error('call() was not transformed. Ensure the zero-com plugin is configured.');
+// Client calls this to set up transport (overrides default server-side behavior)
+// In production mode: transformed by plugin to assignment
+const call = (fn) => {
+    globalThis.ZERO_COM_CLIENT_CALL = fn;
 };
 exports.call = call;

package/lib/webpack-loader.d.ts

@@ -2,5 +2,6 @@ import type { LoaderContext } from 'webpack';
 import { ServerFuncRegistry } from './common';
 export interface ZeroComLoaderOptions {
     registry: ServerFuncRegistry;
+    development: boolean;
 }
-export default function zeroComLoader(this: LoaderContext<ZeroComLoaderOptions>, source: string): string;
+export default function zeroComLoader(this: LoaderContext<ZeroComLoaderOptions>, source: string): void;

package/lib/webpack-loader.js

@@ -9,10 +9,13 @@ const common_1 = require("./common");
 function zeroComLoader(source) {
     const options = this.getOptions();
     const filePath = this.resourcePath;
-    const result = (0, common_1.transformSourceFile)(filePath, source, options.registry);
+    const result = (0, common_1.transformSourceFile)(filePath, source, options.registry, {
+        development: options.development
+    });
     if (!result.transformed) {
-        return source;
+        this.callback(null, source);
+        return;
     }
     console.log(`[ZeroComWebpackPlugin] Transformed: ${path_1.default.basename(filePath)}`);
-    return result.content;
+    this.callback(null, result.content, result.map);
 }

package/lib/webpack.js

@@ -24,7 +24,7 @@ class ZeroComWebpackPlugin {
             enforce: 'pre',
             use: [{
                     loader: loaderPath,
-                    options: { registry: this.registry }
+                    options: { registry: this.registry, development: this.options.development }
                 }]
         };
         compiler.options.module.rules.unshift(loaderRule);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-com",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "main": "index.js",
   "repository": "https://github.com/yosbelms/zero-com",
   "keywords": [
@@ -22,6 +22,7 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
+    "magic-string": "^0.30.21",
     "minimatch": "^10.0.1",
     "ts-morph": "^26.0.0"
   },