zero-com 0.0.8 → 1.2.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'
 ```
@@ -79,28 +72,15 @@ import { getPhones } '../server/phones'
 
 Zero-com does not define any transport layer, it is up to you to create one or reuse your own. This means you have complete control over how data is sent between the client and server.
 
-### Communication Flow
-
-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-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 `call` from `zero-com` and pass your transport function.
 
 ```javascript
 // client/transport.js
-window.ZERO_COM_CLIENT_SEND = async ({ funcId, params }) => {
+import { call } from 'zero-com';
+
+call(async (funcId, params) => {
   const response = await fetch('http://localhost:8000/api', {
     method: 'POST',
     headers: {
@@ -109,24 +89,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 +130,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 +149,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 +167,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 +181,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 +202,11 @@ async function main() {
 main();
 ```
 
-```javascript
-// src/client/transport.js
-window.ZERO_COM_CLIENT_SEND = async ({ funcId, params }) => {
+```typescript
+// src/client/transport.ts
+import { call } from 'zero-com';
+
+call(async (funcId, params) => {
   const response = await fetch('http://localhost:8000/api', {
     method: 'POST',
     headers: {
@@ -238,16 +215,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';
 
-export const getPhones = serverFn(async (ctx, name) => {
+type Context = {
+  req: any,
+  res: any
+}
+
+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 +242,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 +253,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 +280,7 @@ module.exports = {
     path: __dirname + '/dist',
   },
   plugins: [
-    new ZeroComWebpackPlugin({
-      patterns: {
-        client: 'src/client/**',
-        server: 'src/server/api/**',
-      },
-    }),
+    new ZeroComWebpackPlugin(),
   ],
 };
 ```
@@ -327,12 +298,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 declare const ZERO_COM_CLIENT_SEND = "ZERO_COM_CLIENT_SEND";
+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 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 CALL_NAME = "call";
+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.ZERO_COM_CLIENT_SEND = 'ZERO_COM_CLIENT_SEND';
+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.CALL_NAME = exports.HANDLE_NAME = exports.SERVER_FUNCTION_WRAPPER_NAME = 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 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';
-const formatFuncIdName = (funcName, path, line) => {
-    return `${funcName}@${path}:${line}`;
+exports.SERVER_FUNCTION_WRAPPER_NAME = 'func';
+exports.HANDLE_NAME = 'handle';
+exports.CALL_NAME = 'call';
+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_CALL, replacement: `__ZERO_COM_CLIENT_CALL_${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_CALL}('${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.CALL_NAME)
+            return;
+        const args = callExpr.getArguments();
+        if (args.length < 1)
+            return;
+        callExpr.replaceWithText(`globalThis.${exports.ZERO_COM_CLIENT_CALL} = ${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_CALL: (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 call: (_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.call = 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_CALL = fn
+const call = (_fn) => {
+    throw new Error('call() was not transformed. Ensure the zero-com plugin is configured.');
+};
+exports.call = call;

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.8",
+  "version": "1.2.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;