zero-com 0.0.7-s → 1.0.0

package/README.md

@@ -1,6 +1,6 @@
 # Zero-com
 
-It is a zero-byte no-lib utility for transparently communicating client-side and server-side modules residing in the same full-stack project.
+A ~420 Bytes utility for transparently communicating client and server in full-stack projects through compile-time code transformation, with end-to-end static type checking.
 
 ## Table of Contents
 
@@ -27,10 +27,6 @@ module.exports = {
   plugins: [
     new ZeroComWebpackPlugin({
       development: true,
-      patterns: {
-        client: 'src/client/**',
-        server: 'src/server/api/**',
-      },
     }),
   ],
 };
@@ -49,10 +45,6 @@ export default {
   plugins: [
     zeroComRollupPlugin({
       development: true,
-      patterns: {
-        client: 'src/client/**',
-        server: 'src/server/api/**',
-      },
     }),
   ],
 };
@@ -61,16 +53,17 @@ export default {
 The above code will identify all the references from client-side code to the server-side files and will tranform the modules to comunicate through your defined transport layer. The only callable functions in the server-side modules will be the exported async functions. See the example below.
 
 Server side
-```js
+```ts
 // server/phones.ts
-export async function getPhones() { }
+import { func } from 'zero-com';
 
-// or
-export const getPhones = async () => { }
+export const getPhones = func(async () => { 
+  // ...
+})
 ```
 
 Client side
-```js
+```tsx
 // client/phones.tsx
 import { getPhones } '../server/phones'
 ```
@@ -84,23 +77,25 @@ Zero-com does not define any transport layer, it is up to you to create one or r
 The following diagram illustrates the communication flow between the client and server:
 
 ```
-+--------+      +-----------------------------+      +-------------+
-| Client |----->| window.ZERO_COM_CLIENT_SEND |----->| Your Server |
-+--------+      +-----------------------------+      +-------------+
-                                                           |
-                                                           v
-+--------+      +-------------------------+      +-------------------+
-| Client |<-----| (Your custom transport) |<-----| someCustomHandler |
-+--------+      +-------------------------+      +-------------------+
++--------+      +----------------------------------+      +-------------+
+| Client |----->| globalThis.ZERO_COM_CLIENT_SEND  |----->| Your Server |
++--------+      +----------------------------------+      +-------------+
+                                                                |
+                                                                v
++--------+      +-------------------------+      +--------------------------------------+
+| Client |<-----| (Your custom transport) |<-----| globalThis.ZERO_COM_SERVER_REGISTRY  |
++--------+      +-------------------------+      +--------------------------------------+
 ```
 
 ### Client-side
 
-All messages from the client-side will be sent using the `window.ZERO_COM_CLIENT_SEND` function. You need to define this function in your client-side code.
+All messages from the client-side will be sent using the transport function you define. Import `send` from `zero-com` and pass your transport function.
 
 ```javascript
 // client/transport.js
-window.ZERO_COM_CLIENT_SEND = async ({ funcId, params }) => {
+import { send } from 'zero-com';
+
+send(async (funcId, params) => {
   const response = await fetch('http://localhost:8000/api', {
     method: 'POST',
     headers: {
@@ -109,24 +104,19 @@ window.ZERO_COM_CLIENT_SEND = async ({ funcId, params }) => {
     body: JSON.stringify({ funcId, params }),
   });
   return await response.json();
-};
+});
 ```
 
 ### Server-side
 
-On the server-side, you need to create a handler that receives messages from the client, executes the corresponding function, and returns the result. The `global.ZERO_COM_SERVER_REGISTRY` object contains all the server functions that can be called from the client.
+On the server-side, you need to create a handler that receives messages from the client, executes the corresponding function, and returns the result. Import `handle` from `zero-com` and call it with the function ID, context, and arguments.
 
 ```javascript
 // server/api.js
-import { execServerFn } from 'zero-com';
+import { handle } from 'zero-com';
 
 const someCustomHandler = async (message) => {
-  const func = global.ZERO_COM_SERVER_REGISTRY[message.funcId];
-  if (func) {
-    return await execServerFn(func, message.params);
-  } else {
-    throw new Error(`Function with id ${message.funcId} not found.`);
-  }
+  return await handle(message.funcId, null, message.params);
 };
 
 // Example of how to use the handler with an Express server
@@ -155,13 +145,17 @@ Often you want to pass a context-related object to the server functions to have
 
 ### Passing Context to Server Functions
 
-To pass context to a server function, you need to wrap the function in `serverFn` and receive the context as the first parameter.
+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.
 
-```javascript
-// server/api/phones.js
-import { serverFn } from 'zero-com';
+```typescript
+// server/api/phones.ts
+import { func, context } from 'zero-com';
+
+type MyContext = {
+    request: any
+}
 
-export const getPhones = serverFn(async (ctx, name) => {
+export const getPhones = func(async (ctx: context<MyContext>, name: string) => {
   // ctx is the context object passed from the server
   console.log(ctx.request.headers);
   // ... your code
@@ -170,17 +164,16 @@ export const getPhones = serverFn(async (ctx, name) => {
 
 ### Providing Context on the Server
 
-You can pass the context to `execServerFn` when you execute the server function.
+You can pass the context to `handle` when you execute the server function.
 
 ```javascript
 // server/api.js
-import { execServerFn } from 'zero-com';
+import { handle } from 'zero-com';
 
 const myHandler = (request, response, message) => {
   const ctx = { request, response };
-  const func = global.ZERO_COM_SERVER_REGISTRY[message.funcId];
   // pass context on exec
-  return execServerFn(func, ctx, message.params);
+  return handle(message.funcId, ctx, message.params);
 };
 ```
 
@@ -189,9 +182,6 @@ const myHandler = (request, response, message) => {
 | Option      | Type      | Description                                                                 |
 |-------------|-----------|-----------------------------------------------------------------------------|
 | `development` | `boolean`   | If `false`, will add internal variable renaming to the final bundle.        |
-| `patterns`    | `object`    |                                                                             |
-| `patterns.client` | `string` | A glob pattern to identify client-side files.                               |
-| `patterns.server` | `string` | A glob pattern to identify server-side files.                               |
 
 ## Complete Example
 
@@ -206,17 +196,17 @@ Here's a complete example of how to use Zero-com in a project.
 ├── rollup.config.js
 └── src
     ├── client
-    │   ├── index.js
-    │   └── transport.js
+    │   ├── index.ts
+    │   └── transport.ts
     └── server
         └── api
-            └── phones.js
+            └── phones.ts
 ```
 
 ### Client-side
 
-```javascript
-// src/client/index.js
+```typescript
+// src/client/index.ts
 import { getPhones } from '../../server/api/phones';
 
 async function main() {
@@ -227,9 +217,11 @@ async function main() {
 main();
 ```
 
-```javascript
-// src/client/transport.js
-window.ZERO_COM_CLIENT_SEND = async ({ funcId, params }) => {
+```typescript
+// src/client/transport.ts
+import { send } from 'zero-com';
+
+send(async (funcId, params) => {
   const response = await fetch('http://localhost:8000/api', {
     method: 'POST',
     headers: {
@@ -238,16 +230,21 @@ window.ZERO_COM_CLIENT_SEND = async ({ funcId, params }) => {
     body: JSON.stringify({ funcId, params }),
   });
   return await response.json();
-};
+});
 ```
 
 ### Server-side
 
-```javascript
-// src/server/api/phones.js
-import { serverFn } from 'zero-com';
+```typescript
+// src/server/api/phones.ts
+import { func, context } from 'zero-com';
+
+type Context = {
+    req: any,
+    res: any
+}
 
-export const getPhones = serverFn(async (ctx, name) => {
+export const getPhones = func(async (ctx: context<Context>, name: string) => {
   // In a real application, you would fetch this from a database
   const allPhones = [
     { name: 'iPhone 13', brand: 'Apple' },
@@ -260,10 +257,10 @@ export const getPhones = serverFn(async (ctx, name) => {
 
 ### Server
 
-```javascript
-// server.js
+```typescript
+// server.ts
 import express from 'express';
-import { execServerFn } from 'zero-com';
+import { handle } from 'zero-com';
 import './src/server/api/phones.js'; // Make sure to import the server-side modules
 
 const app = express();
@@ -271,17 +268,11 @@ app.use(express.json());
 
 app.post('/api', async (req, res) => {
   const { funcId, params } = req.body;
-  const func = global.ZERO_COM_SERVER_REGISTRY[funcId];
-
-  if (func) {
-    try {
-      const result = await execServerFn(func, { req, res }, params);
-      res.json(result);
-    } catch (error) {
-      res.status(500).json({ error: error.message });
-    }
-  } else {
-    res.status(404).json({ error: `Function with id ${funcId} not found.` });
+  try {
+    const result = await handle(funcId, { req, res }, params);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
   }
 });
 
@@ -304,12 +295,7 @@ module.exports = {
     path: __dirname + '/dist',
   },
   plugins: [
-    new ZeroComWebpackPlugin({
-      patterns: {
-        client: 'src/client/**',
-        server: 'src/server/api/**',
-      },
-    }),
+    new ZeroComWebpackPlugin(),
   ],
 };
 ```
@@ -327,12 +313,7 @@ export default {
     format: 'cjs',
   },
   plugins: [
-    zeroComRollupPlugin({
-      patterns: {
-        client: 'src/client/**',
-        server: 'src/server/api/**',
-      },
-    }),
+    zeroComRollupPlugin(),
   ],
 };
 ```

package/index.d.ts

@@ -1 +1 @@
-export * from './lib/index';
+export * from './lib/runtime';

package/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./lib/index"), exports);
+__exportStar(require("./lib/runtime"), exports);

package/lib/common.d.ts

@@ -1,10 +1,42 @@
+import { CallExpression, Project, SourceFile } from 'ts-morph';
 export type Options = {
     development?: boolean;
-    patterns: {
-        client: string;
-        server: string;
-    };
 };
+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_SEND = "ZERO_COM_CLIENT_SEND";
 export declare const ZERO_COM_SERVER_REGISTRY = "ZERO_COM_SERVER_REGISTRY";
-export declare const formatFuncIdName: (funcName: string, path: string, line: number) => string;
+export declare const SERVER_FUNCTION_WRAPPER_NAME = "func";
+export declare const HANDLE_NAME = "handle";
+export declare const SEND_NAME = "send";
+export declare const EXEC_FUNC_NAME = "execFunc";
+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;
+export declare const generateCompilationId: () => string;
+export declare const getReplacements: (compilationId: string) => {
+    target: string;
+    replacement: string;
+}[];
+export declare const isFromLibrary: (callExpr: CallExpression, libraryName: string) => boolean;
+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 appendRegistryCode: (sourceFile: SourceFile, fileRegistry: Map<string, ServerFuncInfo>) => string;
+export type TransformResult = {
+    content: string;
+    transformed: boolean;
+};
+export declare const transformSourceFile: (filePath: string, content: string, registry: ServerFuncRegistry) => TransformResult;
+export declare const emitToJs: (filePath: string, content: string) => string;
+export declare const applyReplacements: (code: string, compilationId: string) => string;

package/lib/common.js

@@ -1,9 +1,256 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatFuncIdName = exports.ZERO_COM_SERVER_REGISTRY = exports.ZERO_COM_CLIENT_SEND = void 0;
+exports.applyReplacements = exports.emitToJs = exports.transformSourceFile = exports.appendRegistryCode = 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.EXEC_FUNC_NAME = exports.SEND_NAME = exports.HANDLE_NAME = exports.SERVER_FUNCTION_WRAPPER_NAME = exports.ZERO_COM_SERVER_REGISTRY = exports.ZERO_COM_CLIENT_SEND = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+// Constants
 exports.ZERO_COM_CLIENT_SEND = 'ZERO_COM_CLIENT_SEND';
 exports.ZERO_COM_SERVER_REGISTRY = 'ZERO_COM_SERVER_REGISTRY';
-const formatFuncIdName = (funcName, path, line) => {
-    return `${funcName}@${path}:${line}`;
+exports.SERVER_FUNCTION_WRAPPER_NAME = 'func';
+exports.HANDLE_NAME = 'handle';
+exports.SEND_NAME = 'send';
+exports.EXEC_FUNC_NAME = 'execFunc';
+exports.CONTEXT_TYPE_NAME = 'context';
+exports.LIBRARY_NAME = 'zero-com';
+exports.FILE_EXTENSIONS = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs'];
+const formatFuncIdName = (funcName, filePath, line) => {
+    return `${funcName}@${filePath}:${line}`;
 };
 exports.formatFuncIdName = formatFuncIdName;
+const generateCompilationId = () => String(Math.floor(Math.random() * 1000000));
+exports.generateCompilationId = generateCompilationId;
+const getReplacements = (compilationId) => [
+    { target: exports.ZERO_COM_CLIENT_SEND, replacement: `__ZERO_COM_CLIENT_SEND_${compilationId}` },
+    { target: exports.ZERO_COM_SERVER_REGISTRY, replacement: `__ZERO_COM_SERVER_REGISTRY_${compilationId}` }
+];
+exports.getReplacements = getReplacements;
+// Utilities
+const isFromLibrary = (callExpr, libraryName) => {
+    const symbol = callExpr.getExpression().getSymbol();
+    if (!symbol)
+        return false;
+    for (const decl of symbol.getDeclarations()) {
+        const kind = decl.getKind();
+        if (kind === ts_morph_1.ts.SyntaxKind.ImportSpecifier || kind === ts_morph_1.ts.SyntaxKind.NamespaceImport) {
+            const importDecl = decl.getFirstAncestorByKind(ts_morph_1.ts.SyntaxKind.ImportDeclaration);
+            if ((importDecl === null || importDecl === void 0 ? void 0 : importDecl.getModuleSpecifierValue()) === libraryName)
+                return true;
+        }
+    }
+    return false;
+};
+exports.isFromLibrary = isFromLibrary;
+const resolveFilePath = (basePath) => {
+    for (const ext of exports.FILE_EXTENSIONS) {
+        const tryPath = basePath + ext;
+        if (fs_1.default.existsSync(tryPath))
+            return tryPath;
+    }
+    for (const ext of exports.FILE_EXTENSIONS.slice(1)) {
+        const tryPath = path_1.default.join(basePath, 'index' + ext);
+        if (fs_1.default.existsSync(tryPath))
+            return tryPath;
+    }
+    return '';
+};
+exports.resolveFilePath = resolveFilePath;
+const createProject = () => new ts_morph_1.Project({
+    compilerOptions: { target: ts_morph_1.ts.ScriptTarget.ES2017, module: ts_morph_1.ts.ModuleKind.ESNext }
+});
+exports.createProject = createProject;
+const getCalleeName = (callExpr) => {
+    const expr = callExpr.getExpression();
+    const kind = expr.getKind();
+    if (kind === ts_morph_1.SyntaxKind.Identifier)
+        return expr.getText();
+    if (kind === ts_morph_1.SyntaxKind.PropertyAccessExpression)
+        return expr.getName();
+    return '';
+};
+const getCalleeFullName = (callExpr) => {
+    const expr = callExpr.getExpression();
+    const kind = expr.getKind();
+    if (kind === ts_morph_1.SyntaxKind.Identifier)
+        return expr.getText();
+    if (kind === ts_morph_1.SyntaxKind.PropertyAccessExpression)
+        return expr.getText();
+    return '';
+};
+// Registry building
+const buildRegistry = (contextDir, registry) => {
+    registry.clear();
+    const scanDirectory = (dir) => {
+        for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')) {
+                scanDirectory(fullPath);
+            }
+            else if (entry.isFile() && exports.FILE_EXTENSIONS.slice(1).includes(path_1.default.extname(entry.name))) {
+                scanFileForServerFunctions(fullPath, contextDir, registry);
+            }
+        }
+    };
+    scanDirectory(contextDir);
+};
+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()) {
+        if (!decl.isExported())
+            continue;
+        const initializer = decl.getInitializer();
+        if (!initializer || initializer.getKind() !== ts_morph_1.SyntaxKind.CallExpression)
+            continue;
+        const callExpr = initializer;
+        if (!(0, exports.isFromLibrary)(callExpr, exports.LIBRARY_NAME))
+            continue;
+        const funcExprText = callExpr.getExpression().getText();
+        if (funcExprText !== exports.SERVER_FUNCTION_WRAPPER_NAME && !funcExprText.endsWith(`.${exports.SERVER_FUNCTION_WRAPPER_NAME}`))
+            continue;
+        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)
+        registry.set(filePath, fileRegistry);
+};
+// Imported functions resolution
+const getImportedServerFunctions = (sourceFile, registry) => {
+    var _a;
+    const importedFuncs = new Map();
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpecifier = importDecl.getModuleSpecifierValue();
+        if (!moduleSpecifier.startsWith('.'))
+            continue;
+        const resolvedPath = (0, exports.resolveFilePath)(path_1.default.resolve(path_1.default.dirname(sourceFile.getFilePath()), moduleSpecifier));
+        const fileRegistry = registry.get(resolvedPath);
+        if (!fileRegistry)
+            continue;
+        for (const namedImport of importDecl.getNamedImports()) {
+            const funcInfo = fileRegistry.get(namedImport.getName());
+            if (funcInfo)
+                importedFuncs.set(((_a = namedImport.getAliasNode()) === null || _a === void 0 ? void 0 : _a.getText()) || namedImport.getName(), funcInfo);
+        }
+        const nsImport = importDecl.getNamespaceImport();
+        if (nsImport) {
+            fileRegistry.forEach((info, name) => importedFuncs.set(`${nsImport.getText()}.${name}`, info));
+        }
+    }
+    return importedFuncs;
+};
+exports.getImportedServerFunctions = getImportedServerFunctions;
+// Transformations
+const transformCallSites = (sourceFile, importedFuncs) => {
+    if (importedFuncs.size === 0)
+        return false;
+    let modified = false;
+    sourceFile.forEachDescendant((node) => {
+        if (node.getKind() !== ts_morph_1.SyntaxKind.CallExpression)
+            return;
+        const callExpr = node;
+        const calleeName = getCalleeFullName(callExpr);
+        const funcInfo = importedFuncs.get(calleeName);
+        if (!funcInfo)
+            return;
+        const args = callExpr.getArguments().map(a => a.getText()).join(', ');
+        callExpr.replaceWithText(`globalThis.${exports.ZERO_COM_CLIENT_SEND}('${funcInfo.funcId}', [${args}])`);
+        modified = true;
+    });
+    return modified;
+};
+exports.transformCallSites = transformCallSites;
+const transformHandleCalls = (sourceFile) => {
+    let modified = false;
+    sourceFile.forEachDescendant((node) => {
+        if (node.getKind() !== ts_morph_1.SyntaxKind.CallExpression)
+            return;
+        const callExpr = node;
+        if (!(0, exports.isFromLibrary)(callExpr, exports.LIBRARY_NAME) || getCalleeName(callExpr) !== exports.HANDLE_NAME)
+            return;
+        const args = callExpr.getArguments();
+        if (args.length < 3)
+            return;
+        callExpr.replaceWithText(`${exports.EXEC_FUNC_NAME}(globalThis.${exports.ZERO_COM_SERVER_REGISTRY}[${args[0].getText()}], ${args[1].getText()}, ${args[2].getText()})`);
+        modified = true;
+    });
+    return modified;
+};
+exports.transformHandleCalls = transformHandleCalls;
+const transformSendCalls = (sourceFile) => {
+    let modified = false;
+    sourceFile.forEachDescendant((node) => {
+        if (node.getKind() !== ts_morph_1.SyntaxKind.CallExpression)
+            return;
+        const callExpr = node;
+        if (!(0, exports.isFromLibrary)(callExpr, exports.LIBRARY_NAME) || getCalleeName(callExpr) !== exports.SEND_NAME)
+            return;
+        const args = callExpr.getArguments();
+        if (args.length < 1)
+            return;
+        callExpr.replaceWithText(`globalThis.${exports.ZERO_COM_CLIENT_SEND} = ${args[0].getText()}`);
+        modified = true;
+    });
+    return modified;
+};
+exports.transformSendCalls = transformSendCalls;
+const appendRegistryCode = (sourceFile, fileRegistry) => {
+    const registrations = Array.from(fileRegistry.values())
+        .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 project = (0, exports.createProject)();
+    const sourceFile = project.createSourceFile(filePath, content, { overwrite: true });
+    const fileRegistry = registry.get(filePath);
+    const isServerFunctionFile = fileRegistry && fileRegistry.size > 0;
+    const importedFuncs = (0, exports.getImportedServerFunctions)(sourceFile, registry);
+    // Don't transform calls to functions defined in the same file
+    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);
+    if (isServerFunctionFile) {
+        return { content: (0, exports.appendRegistryCode)(sourceFile, fileRegistry), transformed: true };
+    }
+    if (callsTransformed || handleTransformed || sendTransformed) {
+        return { content: sourceFile.getFullText(), transformed: true };
+    }
+    return { content, transformed: false };
+};
+exports.transformSourceFile = transformSourceFile;
+const emitToJs = (filePath, content) => {
+    const project = (0, exports.createProject)();
+    project.createSourceFile(filePath, content, { overwrite: true });
+    const files = project.emitToMemory().getFiles();
+    return files.length > 0 ? files[0].text : content;
+};
+exports.emitToJs = emitToJs;
+const applyReplacements = (code, compilationId) => {
+    let result = code;
+    for (const { target, replacement } of (0, exports.getReplacements)(compilationId)) {
+        result = result.replaceAll(target, replacement);
+    }
+    return result;
+};
+exports.applyReplacements = applyReplacements;

package/lib/rollup.d.ts

@@ -1,3 +1,3 @@
 import { Plugin } from 'rollup';
 import { Options } from './common';
-export declare function zeroComRollupPlugin(options: Options): Plugin;
+export declare function zeroComRollupPlugin(options?: Options): Plugin;

package/lib/rollup.js

@@ -14,158 +14,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zeroComRollupPlugin = zeroComRollupPlugin;
 const fs_1 = __importDefault(require("fs"));
-const minimatch_1 = require("minimatch");
 const path_1 = __importDefault(require("path"));
-const ts_morph_1 = require("ts-morph");
-const typescript_1 = __importDefault(require("typescript"));
 const common_1 = require("./common");
-function zeroComRollupPlugin(options) {
-    const { development = true, patterns } = options;
-    const compilationId = String(Math.floor(Math.random() * 1000000));
-    const clientPattern = patterns.client;
-    const serverPattern = patterns.server;
-    const replacements = [
-        { target: common_1.ZERO_COM_CLIENT_SEND, replacement: `__ZERO_COM_CLIENT_SEND_${compilationId}` },
-        { target: common_1.ZERO_COM_SERVER_REGISTRY, replacement: `__ZERO_COM_SERVER_REGISTRY_${compilationId}` }
-    ];
+function zeroComRollupPlugin(options = {}) {
+    const { development = true } = options;
+    const compilationId = (0, common_1.generateCompilationId)();
+    const registry = new Map();
     return {
         name: 'zero-com-rollup-plugin',
-        resolveId(source, importer, options) {
+        buildStart() {
+            (0, common_1.buildRegistry)(process.cwd(), registry);
+            console.log(`[ZeroComRollupPlugin] Found ${registry.size} files with server functions`);
+        },
+        resolveId(source, importer, opts) {
             return __awaiter(this, void 0, void 0, function* () {
-                if (!importer)
-                    return null;
-                const resolveResult = yield this.resolve(source, importer, Object.assign(Object.assign({}, options), { skipSelf: true }));
-                if (!resolveResult)
+                if (!importer || (!source.startsWith('.') && !source.startsWith('/')))
                     return null;
-                const absolutePath = resolveResult.id;
-                const isServerFile = (0, minimatch_1.minimatch)(absolutePath, path_1.default.join(process.cwd(), serverPattern));
-                if (!isServerFile)
+                const result = yield this.resolve(source, importer, Object.assign(Object.assign({}, opts), { skipSelf: true }));
+                if (!result)
                     return null;
-                const requestedFromClient = (0, minimatch_1.minimatch)(importer, path_1.default.join(process.cwd(), clientPattern));
-                const tsPath = absolutePath + '.ts';
-                const jsPath = absolutePath + '.js';
-                const mjsPath = absolutePath + '.mjs';
-                let resolvedPath = '';
-                if (fs_1.default.existsSync(tsPath)) {
-                    resolvedPath = tsPath;
-                }
-                else if (fs_1.default.existsSync(jsPath)) {
-                    resolvedPath = jsPath;
-                }
-                else if (fs_1.default.existsSync(mjsPath)) {
-                    resolvedPath = mjsPath;
-                }
-                else {
+                let resolvedPath = (0, common_1.resolveFilePath)(result.id);
+                if (!resolvedPath && fs_1.default.existsSync(result.id))
+                    resolvedPath = result.id;
+                if (!resolvedPath)
                     return null;
-                }
-                return {
-                    id: resolvedPath,
-                    meta: {
-                        isClient: requestedFromClient,
-                    }
-                };
+                return { id: resolvedPath, meta: { needsTransform: true } };
             });
         },
         load(id) {
-            var _a;
-            const meta = (_a = this.getModuleInfo(id)) === null || _a === void 0 ? void 0 : _a.meta;
-            if (meta === undefined || meta.isClient === undefined)
+            var _a, _b;
+            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 originalContent = fs_1.default.readFileSync(id, 'utf8');
-            const project = new ts_morph_1.Project({
-                compilerOptions: {
-                    target: typescript_1.default.ScriptTarget.ES2017,
-                    module: typescript_1.default.ModuleKind.ESNext,
-                },
-            });
-            const sourceFile = project.createSourceFile(id, originalContent, { overwrite: true });
-            if (meta.isClient) {
-                sourceFile.getFunctions().forEach(func => {
-                    if (func.isExported() && func.isAsync()) {
-                        const funcName = String(func.getName());
-                        const lineNumber = func.getStartLineNumber();
-                        const funcParams = func.getParameters().map(p => p.getName()).join(', ');
-                        const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(process.cwd(), id), lineNumber);
-                        const newFunctionBody = `return window.${common_1.ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`;
-                        func.setBodyText(newFunctionBody);
-                    }
-                });
-                sourceFile.getVariableDeclarations().forEach(decl => {
-                    const initializer = decl.getInitializer();
-                    if (!initializer || !decl.isExported())
-                        return;
-                    if (initializer instanceof ts_morph_1.ArrowFunction && initializer.isAsync()) {
-                        const funcName = decl.getName();
-                        const lineNumber = decl.getStartLineNumber();
-                        const funcParams = initializer.getParameters().map(p => p.getName()).join(', ');
-                        const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(process.cwd(), id), lineNumber);
-                        const newFunctionBody = `return window.${common_1.ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`;
-                        initializer.setBodyText(newFunctionBody);
-                    }
-                    else if (initializer.getKind() === typescript_1.default.SyntaxKind.CallExpression && initializer.getExpression().getText() === 'serverFn') {
-                        const call = initializer;
-                        const arg = call.getArguments()[0];
-                        if (arg && arg instanceof ts_morph_1.ArrowFunction) {
-                            const funcName = decl.getName();
-                            const lineNumber = decl.getStartLineNumber();
-                            const funcParams = arg.getParameters().map(p => p.getName()).join(', ');
-                            const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(process.cwd(), id), lineNumber);
-                            const newFunctionBody = `return window.${common_1.ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`;
-                            // Create a new arrow function string
-                            const newArrowFunc = `(${funcParams}) => { ${newFunctionBody} }`;
-                            // Replace the serverFn call with the new arrow function
-                            decl.setInitializer(newArrowFunc);
-                        }
-                    }
-                });
-            }
-            else {
-                const chunks = [];
-                sourceFile.getFunctions().forEach(func => {
-                    if (func.isExported() && func.isAsync()) {
-                        const funcName = String(func.getName());
-                        const lineNumber = func.getStartLineNumber();
-                        const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(process.cwd(), id), lineNumber);
-                        chunks.push(`global.${common_1.ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`);
-                    }
-                });
-                sourceFile.getVariableDeclarations().forEach(decl => {
-                    const initializer = decl.getInitializer();
-                    if (initializer) {
-                        const isServerFn = initializer.getKind() === typescript_1.default.SyntaxKind.CallExpression && initializer.getExpression().getText() === 'serverFn';
-                        if ((initializer instanceof ts_morph_1.ArrowFunction && decl.isExported() && initializer.isAsync()) ||
-                            (isServerFn && decl.isExported())) {
-                            const funcName = decl.getName();
-                            const lineNumber = decl.getStartLineNumber();
-                            const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(process.cwd(), id), lineNumber);
-                            chunks.push(`global.${common_1.ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`);
-                        }
-                    }
-                });
-                if (chunks.length > 0) {
-                    const textToAdd = `\nif (!global.${common_1.ZERO_COM_SERVER_REGISTRY}) global.${common_1.ZERO_COM_SERVER_REGISTRY} = Object.create(null); ${chunks.join(',')}`;
-                    sourceFile.insertText(sourceFile.getEnd(), textToAdd);
-                }
-            }
-            const result = project.emitToMemory();
-            const newContent = result.getFiles()[0].text;
-            return newContent;
+            const content = fs_1.default.readFileSync(id, 'utf8');
+            const result = (0, common_1.transformSourceFile)(id, content, registry);
+            if (!result.transformed)
+                return null;
+            console.log(`[ZeroComRollupPlugin] Transformed: ${path_1.default.relative(process.cwd(), id)}`);
+            return (0, common_1.emitToJs)(id, result.content);
         },
-        renderChunk(code, chunk, options) {
+        renderChunk(code) {
             if (development)
                 return null;
-            let modified = false;
-            let newCode = code;
-            replacements.forEach(({ target, replacement }) => {
-                if (newCode.includes(target)) {
-                    newCode = newCode.replaceAll(target, replacement);
-                    modified = true;
-                }
-            });
-            if (modified) {
-                return { code: newCode, map: null };
-            }
-            return null;
+            const newCode = (0, common_1.applyReplacements)(code, compilationId);
+            return newCode !== code ? { code: newCode, map: null } : null;
         }
     };
 }

package/lib/runtime.d.ts

@@ -0,0 +1,16 @@
+declare global {
+    var ZERO_COM_SERVER_REGISTRY: {
+        [funcId: string]: (...args: any[]) => any;
+    };
+    var ZERO_COM_CLIENT_SEND: (funcId: string, args: any[]) => Promise<any>;
+}
+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 execFunc: (sfn: ReturnType<typeof func>, ctx: any, args: any[]) => ReturnType<typeof sfn>;
+export declare const handle: (_funcId: string, _ctx: any, _args: any[]) => any;
+export declare const send: (_fn: (funcId: string, args: any[]) => Promise<any>) => void;
+export {};

package/lib/runtime.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.send = exports.handle = exports.execFunc = void 0;
+exports.func = func;
+// Implementation
+function func(fn) {
+    fn.requireContext = true;
+    return fn;
+}
+// Internal implementation - receives the actual function from registry
+const execFunc = (sfn, ctx, args) => {
+    const fn = sfn;
+    if (fn.requireContext) {
+        return fn(ctx, ...args);
+    }
+    else {
+        return fn(...args);
+    }
+};
+exports.execFunc = execFunc;
+// User-facing function - transformed by plugin to execFunc(globalThis.ZERO_COM_SERVER_REGISTRY[funcId], ctx, args)
+const handle = (_funcId, _ctx, _args) => {
+    throw new Error('handle() was not transformed. Ensure the zero-com plugin is configured.');
+};
+exports.handle = handle;
+// User-facing function - transformed by plugin to globalThis.ZERO_COM_CLIENT_SEND = fn
+const send = (_fn) => {
+    throw new Error('send() was not transformed. Ensure the zero-com plugin is configured.');
+};
+exports.send = send;

package/lib/webpack.d.ts

@@ -1,15 +1,9 @@
 import { Compiler } from 'webpack';
 import { Options } from './common';
-export type Message = {
-    funcId: string;
-    params: any[];
-    [key: string]: any;
-};
 export declare class ZeroComWebpackPlugin {
     private options;
     private compilationId;
-    private clientPattern;
-    private serverPattern;
-    constructor(options: Options);
+    private registry;
+    constructor(options?: Options);
     apply(compiler: Compiler): void;
 }

package/lib/webpack.js

@@ -5,157 +5,52 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZeroComWebpackPlugin = void 0;
 const fs_1 = __importDefault(require("fs"));
-const minimatch_1 = require("minimatch");
 const path_1 = __importDefault(require("path"));
-const ts_morph_1 = require("ts-morph");
-const typescript_1 = __importDefault(require("typescript"));
 const common_1 = require("./common");
 class ZeroComWebpackPlugin {
-    constructor(options) {
-        this.options = Object.assign(Object.assign({ development: true }, options), { patterns: Object.assign({}, options.patterns) });
-        this.compilationId = String(Math.floor(Math.random() * 1000000));
-        this.clientPattern = this.options.patterns.client;
-        this.serverPattern = this.options.patterns.server;
+    constructor(options = {}) {
+        this.registry = new Map();
+        this.options = Object.assign({ development: true }, options);
+        this.compilationId = (0, common_1.generateCompilationId)();
     }
     apply(compiler) {
         const pluginName = ZeroComWebpackPlugin.name;
         const { webpack } = compiler;
-        const { RawSource } = webpack.sources;
+        // Build registry before compilation
+        compiler.hooks.beforeCompile.tap(pluginName, () => {
+            (0, common_1.buildRegistry)(compiler.context, this.registry);
+            console.log(`[ZeroComWebpackPlugin] Found ${this.registry.size} files with server functions`);
+        });
+        // Transform files during module resolution
         compiler.hooks.normalModuleFactory.tap(pluginName, (nmf) => {
             nmf.hooks.beforeResolve.tap(pluginName, (resolveData) => {
-                const absolutePath = path_1.default.resolve(resolveData.context, resolveData.request);
-                const isServerFile = (0, minimatch_1.minimatch)(absolutePath, path_1.default.join(compiler.context, this.serverPattern));
-                if (!isServerFile)
+                if (!resolveData.request.startsWith('.') && !resolveData.request.startsWith('/'))
                     return;
-                const requestedFromClient = (0, minimatch_1.minimatch)(resolveData.contextInfo.issuer, path_1.default.join(compiler.context, this.clientPattern));
-                const tsPath = absolutePath + '.ts';
-                const jsPath = absolutePath + '.js';
-                const mjsPath = absolutePath + '.mjs';
-                let resolvedPath = '';
-                if (fs_1.default.existsSync(tsPath)) {
-                    resolvedPath = tsPath;
-                }
-                else if (fs_1.default.existsSync(jsPath)) {
-                    resolvedPath = jsPath;
-                }
-                else if (fs_1.default.existsSync(mjsPath)) {
-                    resolvedPath = mjsPath;
-                }
-                else {
-                    throw new Error('Unable to resolve: ' + absolutePath);
-                }
-                const originalContent = fs_1.default.readFileSync(resolvedPath, 'utf8');
-                const project = new ts_morph_1.Project({
-                    compilerOptions: {
-                        target: typescript_1.default.ScriptTarget.ES2017,
-                        module: typescript_1.default.ModuleKind.ESNext,
-                    },
-                });
-                const sourceFile = project.createSourceFile(absolutePath, originalContent, { overwrite: true });
-                let newModuleContent = '';
-                if (requestedFromClient) {
-                    const generatedFunctions = [];
-                    sourceFile.getFunctions().forEach(func => {
-                        if (func.isExported() && func.isAsync()) {
-                            const funcName = String(func.getName());
-                            const lineNumber = func.getStartLineNumber();
-                            const funcParams = func.getParameters().map(p => p.getName()).join(', ');
-                            const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(compiler.context, absolutePath), lineNumber);
-                            const newFunctionBody = `return window.${common_1.ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`;
-                            func.setBodyText(newFunctionBody);
-                            generatedFunctions.push(func.getText());
-                            console.log('client:', funcId);
-                        }
-                    });
-                    sourceFile.getVariableDeclarations().forEach(decl => {
-                        const initializer = decl.getInitializer();
-                        if (!initializer || !decl.isExported())
-                            return;
-                        if (initializer instanceof ts_morph_1.ArrowFunction && initializer.isAsync()) {
-                            const funcName = decl.getName();
-                            const lineNumber = decl.getStartLineNumber();
-                            const funcParams = initializer.getParameters().map(p => p.getName()).join(', ');
-                            const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(compiler.context, absolutePath), lineNumber);
-                            const newFunctionBody = `return window.${common_1.ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`;
-                            initializer.setBodyText(newFunctionBody);
-                            generatedFunctions.push(decl.getVariableStatementOrThrow().getText());
-                            console.log('client:', funcId);
-                        }
-                        else if (initializer.getKind() === typescript_1.default.SyntaxKind.CallExpression && initializer.getExpression().getText() === 'serverFn') {
-                            const call = initializer;
-                            const arg = call.getArguments()[0];
-                            if (arg && arg instanceof ts_morph_1.ArrowFunction) {
-                                const funcName = decl.getName();
-                                const lineNumber = decl.getStartLineNumber();
-                                const funcParams = arg.getParameters().map(p => p.getName()).join(', ');
-                                const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(compiler.context, absolutePath), lineNumber);
-                                const newFunctionBody = `return window.${common_1.ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`;
-                                // Create a new arrow function string
-                                const newArrowFunc = `(${funcParams}) => { ${newFunctionBody} }`;
-                                // Replace the serverFn call with the new arrow function
-                                decl.setInitializer(newArrowFunc);
-                                generatedFunctions.push(decl.getVariableStatementOrThrow().getText());
-                                console.log('client:', funcId);
-                            }
-                        }
-                    });
-                    newModuleContent = generatedFunctions.join('\n\n');
-                }
-                else {
-                    const chunks = [];
-                    sourceFile.getFunctions().forEach(func => {
-                        if (func.isExported() && func.isAsync()) {
-                            const funcName = String(func.getName());
-                            const lineNumber = func.getStartLineNumber();
-                            const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(compiler.context, absolutePath), lineNumber);
-                            chunks.push(`global.${common_1.ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`);
-                            console.log('server:', funcId);
-                        }
-                    });
-                    sourceFile.getVariableDeclarations().forEach(decl => {
-                        const initializer = decl.getInitializer();
-                        if (initializer) {
-                            const isServerFn = initializer.getKind() === typescript_1.default.SyntaxKind.CallExpression && initializer.getExpression().getText() === 'serverFn';
-                            if ((initializer instanceof ts_morph_1.ArrowFunction && decl.isExported() && initializer.isAsync()) ||
-                                (isServerFn && decl.isExported())) {
-                                const funcName = decl.getName();
-                                const lineNumber = decl.getStartLineNumber();
-                                const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(compiler.context, absolutePath), lineNumber);
-                                chunks.push(`global.${common_1.ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`);
-                                console.log('server:', funcId);
-                            }
-                        }
-                    });
-                    newModuleContent = `${originalContent} if (!global.${common_1.ZERO_COM_SERVER_REGISTRY}) global.${common_1.ZERO_COM_SERVER_REGISTRY} = Object.create(null); ${chunks.join(',')}`;
-                }
-                project.createSourceFile(absolutePath + '.ts', newModuleContent, { overwrite: true });
-                const result = project.emitToMemory();
-                const newContent = result.getFiles()[0].text;
-                const inlineLoader = `data:text/javascript,${encodeURIComponent(newContent)}`;
-                resolveData.request = inlineLoader;
+                const resolvedPath = (0, common_1.resolveFilePath)(path_1.default.resolve(resolveData.context, resolveData.request));
+                if (!resolvedPath || !fs_1.default.existsSync(resolvedPath))
+                    return;
+                const content = fs_1.default.readFileSync(resolvedPath, 'utf8');
+                const result = (0, common_1.transformSourceFile)(resolvedPath, content, this.registry);
+                if (!result.transformed)
+                    return;
+                const jsContent = (0, common_1.emitToJs)(resolvedPath, result.content);
+                resolveData.request = `data:text/javascript,${encodeURIComponent(jsContent)}`;
+                console.log(`[ZeroComWebpackPlugin] Transformed: ${path_1.default.relative(compiler.context, resolvedPath)}`);
             });
         });
+        // Production: minify global names
         if (this.options.development)
             return;
-        const replacements = [
-            { target: common_1.ZERO_COM_CLIENT_SEND, replacement: `__ZERO_COM_CLIENT_SEND_${this.compilationId}` },
-            { target: common_1.ZERO_COM_SERVER_REGISTRY, replacement: `__ZERO_COM_SERVER_REGISTRY_${this.compilationId}` }
-        ];
+        const { RawSource } = webpack.sources;
         compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
             compilation.hooks.processAssets.tap({ name: pluginName, stage: webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE }, (assets) => {
                 for (const assetName in assets) {
-                    if (assetName.endsWith('.js')) {
-                        let assetSource = String(assets[assetName].source());
-                        let modified = false;
-                        replacements.forEach(({ target, replacement }) => {
-                            if (assetSource.includes(target)) {
-                                assetSource = assetSource.replaceAll(target, replacement);
-                                modified = true;
-                            }
-                        });
-                        if (modified) {
-                            compilation.updateAsset(assetName, new RawSource(assetSource));
-                        }
+                    if (!assetName.endsWith('.js'))
+                        continue;
+                    const source = String(assets[assetName].source());
+                    const newSource = (0, common_1.applyReplacements)(source, this.compilationId);
+                    if (newSource !== source) {
+                        compilation.updateAsset(assetName, new RawSource(newSource));
                     }
                 }
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-com",
-  "version": "0.0.7s",
+  "version": "1.0.0",
   "main": "index.js",
   "repository": "https://github.com/yosbelms/zero-com",
   "keywords": [
@@ -13,6 +13,8 @@
   ],
   "scripts": {
     "build": "npx tsc -d",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "clean": "find . -type f \\( -name \"*.js\" -o -name \"*.js.map\" -o -name \"*.d.ts\" -o -name \"*.d.ts.map\" \\) | grep -v \"./node_modules\" | xargs rm",
     "prepublishOnly": "npm run clean && npm run build"
   },
@@ -26,7 +28,8 @@
   "devDependencies": {
     "@types/webpack": "^5.28.5",
     "rollup": "^4.52.5",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.18"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/tsconfig.json

@@ -1,7 +1,6 @@
 {
   "compilerOptions": {
     /* Visit https://aka.ms/tsconfig to read more about this file */
-
     /* Projects */
     // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
     // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
@@ -9,10 +8,11 @@
     // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
     // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
     // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-
     /* Language and Environment */
-    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-    "lib": ["es2021"],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    "target": "es2016", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": [
+      "es2021"
+    ], /* Specify a set of bundled library declaration files that describe the target runtime environment. */
     // "jsx": "preserve",                                /* Specify what JSX code is generated. */
     // "libReplacement": true,                           /* Enable lib replacement. */
     // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
@@ -24,9 +24,8 @@
     // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
     // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
     // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-
     /* Modules */
-    "module": "commonjs",                                /* Specify what module code is generated. */
+    "module": "commonjs", /* Specify what module code is generated. */
     // "rootDir": "./",                                  /* Specify the root folder within your source files. */
     // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
@@ -42,15 +41,13 @@
     // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
     // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
     // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    "resolveJsonModule": true, /* Enable importing .json files. */
     // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
     // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
-
     /* JavaScript Support */
     // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
     // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
     // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-
     /* Emit */
     // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
     // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
@@ -73,19 +70,17 @@
     // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
     // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
     // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-
     /* Interop Constraints */
     // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
     // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
     // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
     // "erasableSyntaxOnly": true,                       /* Do not allow runtime constructs that are not part of ECMAScript. */
     // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
     // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
-
+    "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */
     /* Type Checking */
-    "strict": true,                                      /* Enable all strict type-checking options. */
+    "strict": true, /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
     // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
@@ -105,9 +100,13 @@
     // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
     // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
     // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-
     /* Completeness */
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+    "skipLibCheck": true, /* Skip type checking all .d.ts files. */
+    "paths": {
+      "zero-com": [
+        "./index.ts"
+      ]
+    }
   }
-}
+}

package/lib/index.d.ts

@@ -1,11 +0,0 @@
-declare global {
-    var ZERO_COM_SERVER_REGISTRY: {
-        [funcId: string]: (...args: any[]) => any;
-    };
-    var ZERO_COM_CLIENT_SEND: (...args: any[]) => Promise<any>;
-}
-export declare const serverFn: <Ctx, Rest extends any[], R>(sfn: (ctx: Ctx, ...rest: Rest) => R) => {
-    (...rest: Rest): R;
-    serverFn: (ctx: Ctx, ...rest: Rest) => R;
-};
-export declare const execServerFn: (sfn: ReturnType<typeof serverFn>, ctx: any, args: any[]) => ReturnType<typeof sfn>;

package/lib/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.execServerFn = exports.serverFn = void 0;
-const serverFn = (sfn) => {
-    const clonedSfn = (...rest) => sfn(null, ...rest);
-    clonedSfn.serverFn = sfn;
-    return clonedSfn;
-};
-exports.serverFn = serverFn;
-const execServerFn = (sfn, ctx, args) => {
-    if (sfn.serverFn) {
-        return sfn.serverFn.call(null, ctx, ...args);
-    }
-    else {
-        return sfn.call(null, ...args);
-    }
-};
-exports.execServerFn = execServerFn;