@zap-js/client 0.2.1 → 0.2.3

package/dist/cli/commands/build.js

@@ -2,8 +2,9 @@ import { execSync } from 'child_process';
 import { join, resolve } from 'path';
 import { existsSync, mkdirSync, copyFileSync, readdirSync, statSync, rmSync, writeFileSync } from 'fs';
 import { cliLogger } from '../utils/logger.js';
-import { resolveBinary, getPlatformIdentifier } from '../utils/binary-resolver.js';
+import { resolveBinary, getPlatformIdentifier, resolveSpliceBinary } from '../utils/binary-resolver.js';
 import { validateBuildStructure } from '../utils/build-validator.js';
+import { buildUserServerRelease } from '../utils/user-server.js';
 /**
  * Build for production
  */
@@ -63,6 +64,8 @@ export async function buildCommand(options) {
         // This happens AFTER frontend build so Vite doesn't overwrite it
         mkdirSync(join(outputDir, 'bin'), { recursive: true });
         await buildRust(outputDir, options);
+        // Step 4.5: Build user server and copy Splice binary (if available)
+        await buildUserServerAndSplice(outputDir);
         // Step 5: Create production config
         await createProductionConfig(outputDir, staticDir);
         // Step 6: Create build manifest
@@ -421,3 +424,32 @@ function getBinarySize(path) {
         return 'unknown';
     }
 }
+/**
+ * Build user's Rust server and copy Splice binary to dist/bin/
+ */
+async function buildUserServerAndSplice(outputDir) {
+    const projectDir = process.cwd();
+    // 1. Try to resolve pre-built Splice binary
+    const spliceBinary = resolveSpliceBinary(projectDir);
+    if (spliceBinary && existsSync(spliceBinary)) {
+        cliLogger.spinner('splice', 'Copying Splice binary...');
+        try {
+            const destBinary = join(outputDir, 'bin', 'splice');
+            copyFileSync(spliceBinary, destBinary);
+            execSync(`chmod +x "${destBinary}"`, { stdio: 'pipe' });
+            cliLogger.succeedSpinner('splice', 'Splice binary copied');
+        }
+        catch (error) {
+            cliLogger.warn('Failed to copy Splice binary');
+        }
+    }
+    else {
+        cliLogger.info('Splice binary not found (skipping)');
+    }
+    // 2. Build user server if it exists
+    const success = await buildUserServerRelease(projectDir, outputDir);
+    if (!success) {
+        // Warning already logged by buildUserServerRelease
+        return;
+    }
+}

package/dist/cli/commands/serve.js

@@ -6,6 +6,7 @@ import { pathToFileURL } from 'url';
 import { findAvailablePort } from '../utils/port-finder.js';
 import { IpcServer } from '../../runtime/index.js';
 import { cliLogger } from '../utils/logger.js';
+import { SpliceManager } from '../../dev-server/splice-manager.js';
 // Register tsx loader for TypeScript imports
 let tsxRegistered = false;
 async function ensureTsxRegistered() {
@@ -107,6 +108,31 @@ async function runProductionServer(binPath, options, workDir, prodConfig) {
     }
     // Generate unique socket path
     const socketPath = join(tmpdir(), `zap-prod-${Date.now()}-${Math.random().toString(36).substring(7)}.sock`);
+    // Check for Splice and user server binaries
+    let spliceManager = null;
+    const spliceBinPath = join(workDir, 'bin', 'splice');
+    const userServerBinPath = join(workDir, 'bin', 'server');
+    if (existsSync(spliceBinPath) && existsSync(userServerBinPath)) {
+        cliLogger.spinner('splice-prod', 'Starting Splice...');
+        const spliceSocketPath = join(tmpdir(), `splice-prod-${Date.now()}.sock`);
+        spliceManager = new SpliceManager({
+            spliceBinaryPath: spliceBinPath,
+            workerBinaryPath: userServerBinPath,
+            socketPath: spliceSocketPath,
+            maxConcurrency: 1024,
+            timeout: 30,
+        });
+        try {
+            await spliceManager.start();
+            cliLogger.succeedSpinner('splice-prod', 'Splice started');
+        }
+        catch (err) {
+            cliLogger.failSpinner('splice-prod', 'Splice failed to start');
+            const message = err instanceof Error ? err.message : String(err);
+            cliLogger.warn(`Continuing without Splice: ${message}`);
+            spliceManager = null;
+        }
+    }
     // Start IPC server for TypeScript handlers
     cliLogger.spinner('ipc', 'Starting IPC server...');
     const ipcServer = new IpcServer(socketPath);
@@ -131,6 +157,10 @@ async function runProductionServer(binPath, options, workDir, prodConfig) {
         },
         health_check_path: '/health',
     };
+    // Add Splice socket if available
+    if (spliceManager && spliceManager.isRunning()) {
+        zapConfig.splice_socket_path = spliceManager.getSocketPath();
+    }
     // Also check for static directory in workDir
     const staticDir = join(workDir, 'static');
     if (existsSync(staticDir) && zapConfig.static_files.length === 0) {
@@ -173,7 +203,7 @@ async function runProductionServer(binPath, options, workDir, prodConfig) {
         cliLogger.failSpinner('rpc', 'Failed to connect RPC client');
         const message = err instanceof Error ? err.message : String(err);
         cliLogger.error(message);
-        cleanup(ipcServer, tempConfigPath);
+        cleanup(ipcServer, tempConfigPath, spliceManager);
         if (!rustProcess.killed) {
             rustProcess.kill();
         }
@@ -198,7 +228,7 @@ async function runProductionServer(binPath, options, workDir, prodConfig) {
             if (output.includes('error') || output.includes('Error')) {
                 cliLogger.failSpinner('rust', 'Server failed to start');
                 cliLogger.error(output);
-                cleanup(ipcServer, tempConfigPath);
+                cleanup(ipcServer, tempConfigPath, spliceManager);
                 process.exit(1);
             }
         }
@@ -206,13 +236,13 @@ async function runProductionServer(binPath, options, workDir, prodConfig) {
     });
     rustProcess.on('error', (err) => {
         cliLogger.failSpinner('rust', `Failed to start: ${err.message}`);
-        cleanup(ipcServer, tempConfigPath);
+        cleanup(ipcServer, tempConfigPath, spliceManager);
         process.exit(1);
     });
     rustProcess.on('exit', (code) => {
         if (code !== 0 && code !== null) {
             cliLogger.error(`Server exited with code ${code}`);
-            cleanup(ipcServer, tempConfigPath);
+            cleanup(ipcServer, tempConfigPath, spliceManager);
             process.exit(code);
         }
     });
@@ -234,7 +264,7 @@ async function runProductionServer(binPath, options, workDir, prodConfig) {
         // Stop IPC server
         await ipcServer.stop();
         // Cleanup temp config
-        cleanup(null, tempConfigPath);
+        cleanup(null, tempConfigPath, spliceManager);
         // Force kill after timeout
         setTimeout(() => {
             if (!rustProcess.killed) {
@@ -379,7 +409,15 @@ function formatHandlerResponse(result) {
 /**
  * Cleanup temp files
  */
-function cleanup(ipcServer, configPath) {
+function cleanup(ipcServer, configPath, spliceManager) {
+    if (spliceManager) {
+        try {
+            spliceManager.stop();
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
     if (ipcServer) {
         try {
             ipcServer.stop();

package/dist/cli/utils/binary-resolver.d.ts

@@ -4,7 +4,7 @@
  * 2. Local bin/ directory in user's project (for development/custom builds)
  * 3. Returns null to trigger cargo build fallback
  */
-export declare function resolveBinary(binaryName: 'zap' | 'zap-codegen', projectDir?: string): string | null;
+export declare function resolveBinary(binaryName: 'zap' | 'zap-codegen' | 'splice', projectDir?: string): string | null;
 /**
  * Detects both zap and zap-codegen binaries
  */
@@ -20,3 +20,12 @@ export declare function getPlatformIdentifier(): string;
  * Checks if a platform-specific package is installed
  */
 export declare function isPlatformPackageInstalled(): boolean;
+/**
+ * Resolves the Splice binary using the same resolution strategy
+ *
+ * Resolution order:
+ * 1. Platform-specific npm package (@zap-js/darwin-arm64)
+ * 2. Local bin/ directory (user's project)
+ * 3. null (triggers cargo build fallback)
+ */
+export declare function resolveSpliceBinary(projectDir?: string): string | null;

package/dist/cli/utils/binary-resolver.js

@@ -69,3 +69,14 @@ export function isPlatformPackageInstalled() {
         return false;
     }
 }
+/**
+ * Resolves the Splice binary using the same resolution strategy
+ *
+ * Resolution order:
+ * 1. Platform-specific npm package (@zap-js/darwin-arm64)
+ * 2. Local bin/ directory (user's project)
+ * 3. null (triggers cargo build fallback)
+ */
+export function resolveSpliceBinary(projectDir) {
+    return resolveBinary('splice', projectDir);
+}

package/dist/cli/utils/user-server.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Check if project has a server/Cargo.toml (user's Rust server)
+ */
+export declare function hasUserServer(projectDir: string): boolean;
+/**
+ * Build user's Rust server in development mode
+ * Returns path to built binary or null on failure
+ */
+export declare function buildUserServer(projectDir: string, binaryName?: string): Promise<string | null>;
+/**
+ * Build user's Rust server in release mode for production
+ */
+export declare function buildUserServerRelease(projectDir: string, outputDir: string, binaryName?: string): Promise<boolean>;

package/dist/cli/utils/user-server.js

@@ -0,0 +1,79 @@
+import { existsSync, copyFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { cliLogger } from './logger.js';
+/**
+ * Check if project has a server/Cargo.toml (user's Rust server)
+ */
+export function hasUserServer(projectDir) {
+    const serverCargoToml = join(projectDir, 'server', 'Cargo.toml');
+    return existsSync(serverCargoToml);
+}
+/**
+ * Build user's Rust server in development mode
+ * Returns path to built binary or null on failure
+ */
+export async function buildUserServer(projectDir, binaryName = 'server') {
+    const serverDir = join(projectDir, 'server');
+    if (!existsSync(join(serverDir, 'Cargo.toml'))) {
+        return null;
+    }
+    try {
+        cliLogger.spinner('user-server', 'Building Rust server...');
+        execSync('cargo build --bin ' + binaryName, {
+            cwd: serverDir,
+            stdio: 'pipe',
+        });
+        // Find the built binary
+        const targetDir = join(serverDir, 'target', 'debug');
+        const binaryPath = join(targetDir, binaryName);
+        if (existsSync(binaryPath)) {
+            cliLogger.succeedSpinner('user-server', 'User server built');
+            return binaryPath;
+        }
+        cliLogger.failSpinner('user-server', 'Binary not found after build');
+        return null;
+    }
+    catch (error) {
+        cliLogger.failSpinner('user-server', 'User server build failed');
+        if (error instanceof Error) {
+            cliLogger.error(error.message);
+        }
+        return null;
+    }
+}
+/**
+ * Build user's Rust server in release mode for production
+ */
+export async function buildUserServerRelease(projectDir, outputDir, binaryName = 'server') {
+    const serverDir = join(projectDir, 'server');
+    if (!existsSync(join(serverDir, 'Cargo.toml'))) {
+        cliLogger.info('No user server found (skipping)');
+        return true; // Not an error
+    }
+    try {
+        cliLogger.spinner('user-server-release', 'Building user server (release mode)...');
+        execSync('cargo build --release --bin ' + binaryName, {
+            cwd: serverDir,
+            stdio: 'pipe',
+        });
+        // Copy binary to dist/bin/
+        const srcBinary = join(serverDir, 'target', 'release', binaryName);
+        const destBinary = join(outputDir, 'bin', binaryName);
+        if (existsSync(srcBinary)) {
+            copyFileSync(srcBinary, destBinary);
+            execSync(`chmod +x "${destBinary}"`, { stdio: 'pipe' });
+            cliLogger.succeedSpinner('user-server-release', 'User server built (release)');
+            return true;
+        }
+        cliLogger.failSpinner('user-server-release', 'Binary not found');
+        return false;
+    }
+    catch (error) {
+        cliLogger.failSpinner('user-server-release', 'Build failed');
+        if (error instanceof Error) {
+            cliLogger.error(error.message);
+        }
+        return false;
+    }
+}

package/dist/dev-server/server.d.ts

@@ -12,6 +12,8 @@ export interface DevServerConfig {
     binaryPath?: string;
     /** Path to pre-built zap-codegen binary */
     codegenBinaryPath?: string;
+    /** Path to pre-built splice binary */
+    spliceBinaryPath?: string;
 }
 interface ServerState {
     phase: 'starting' | 'building' | 'ready' | 'rebuilding' | 'error' | 'stopped';
@@ -49,6 +51,9 @@ export declare class DevServer extends EventEmitter {
     private socketPath;
     private currentRouteTree;
     private registeredHandlers;
+    private spliceManager;
+    private splicePath;
+    private userServerBinaryPath;
     private startTime;
     constructor(config: DevServerConfig);
     /**
@@ -99,6 +104,10 @@ export declare class DevServer extends EventEmitter {
      * Build Rust server configuration from routes
      */
     private buildRustConfig;
+    /**
+     * Start Splice supervisor for distributed Rust functions
+     */
+    private startSplice;
     /**
      * Restart Rust server (called when routes change)
      */
@@ -131,6 +140,22 @@ export declare class DevServer extends EventEmitter {
      * Handle config file changes
      */
     private handleConfigChange;
+    /**
+     * Handle user server (server/ Rust files) file changes
+     */
+    private handleUserServerChange;
+    /**
+     * Wait for Splice to detect binary change and reload
+     */
+    private waitForSpliceReload;
+    /**
+     * Run Splice codegen to generate TypeScript bindings
+     */
+    private runSpliceCodegen;
+    /**
+     * Find codegen binary in various locations
+     */
+    private findCodegenBinary;
     /**
      * Print the ready message
      */

package/dist/dev-server/server.js

@@ -3,6 +3,8 @@ import path from 'path';
 import { tmpdir } from 'os';
 import { pathToFileURL } from 'url';
 import { promises as fs } from 'fs';
+import { spawn, execSync } from 'child_process';
+import { existsSync } from 'fs';
 import { FileWatcher } from './watcher.js';
 import { RustBuilder } from './rust-builder.js';
 import { ViteProxy } from './vite-proxy.js';
@@ -12,6 +14,9 @@ import { RouteScannerRunner } from './route-scanner.js';
 import { ProcessManager, IpcServer } from '../runtime/index.js';
 import { initRpcClient } from '../runtime/rpc-client.js';
 import { cliLogger } from '../cli/utils/logger.js';
+import { SpliceManager } from './splice-manager.js';
+import { hasUserServer, buildUserServer } from '../cli/utils/user-server.js';
+import { resolveSpliceBinary } from '../cli/utils/binary-resolver.js';
 // Register tsx loader for TypeScript imports
 // This must be called before any dynamic imports of .ts files
 let tsxRegistered = false;
@@ -52,6 +57,10 @@ export class DevServer extends EventEmitter {
         this.socketPath = '';
         this.currentRouteTree = null;
         this.registeredHandlers = new Map(); // handlerId -> filePath
+        // Splice components for distributed Rust functions
+        this.spliceManager = null;
+        this.splicePath = '';
+        this.userServerBinaryPath = null;
         // Timing
         this.startTime = 0;
         this.config = {
@@ -106,6 +115,7 @@ export class DevServer extends EventEmitter {
     setupEventHandlers() {
         // File watcher events
         this.watcher.on('rust', (event) => this.handleRustChange(event));
+        this.watcher.on('user-server', (event) => this.handleUserServerChange(event));
         this.watcher.on('typescript', (event) => this.handleTypeScriptChange(event));
         this.watcher.on('config', (event) => this.handleConfigChange(event));
         this.watcher.on('error', (err) => this.log('error', `Watcher error: ${err.message}`));
@@ -177,6 +187,11 @@ export class DevServer extends EventEmitter {
             // Phase 2.5: Scan routes
             const routeTree = await this.scanRoutes();
             this.currentRouteTree = routeTree;
+            // Phase 2.75: Check for user server and start Splice if available
+            const hasServer = hasUserServer(this.config.projectDir);
+            if (hasServer) {
+                await this.startSplice();
+            }
             // Phase 3: Start Rust HTTP server with IPC
             await this.startRustServer(routeTree);
             // Phase 4: Start other servers in parallel
@@ -210,7 +225,12 @@ export class DevServer extends EventEmitter {
         this.state.phase = 'stopped';
         cliLogger.newline();
         cliLogger.warn('Shutting down...');
-        // Kill Rust server first (most important)
+        // Stop Splice first
+        if (this.spliceManager) {
+            await this.spliceManager.stop();
+            this.spliceManager = null;
+        }
+        // Kill Rust server (most important)
         if (this.processManager) {
             this.processManager.stop();
             this.processManager = null;
@@ -473,7 +493,7 @@ export class DevServer extends EventEmitter {
      * Build Rust server configuration from routes
      */
     buildRustConfig(routes) {
-        return {
+        const config = {
             port: this.config.rustPort,
             hostname: '127.0.0.1',
             ipc_socket_path: this.socketPath,
@@ -487,6 +507,56 @@ export class DevServer extends EventEmitter {
             health_check_path: '/health',
             metrics_path: '/metrics',
         };
+        // Add Splice socket if available
+        if (this.splicePath && this.spliceManager?.isRunning()) {
+            config.splice_socket_path = this.splicePath;
+        }
+        return config;
+    }
+    /**
+     * Start Splice supervisor for distributed Rust functions
+     */
+    async startSplice() {
+        cliLogger.spinner('splice', 'Starting Splice supervisor...');
+        try {
+            // 1. Resolve Splice binary
+            const spliceBinaryPath = this.config.spliceBinaryPath ||
+                resolveSpliceBinary(this.config.projectDir);
+            if (!spliceBinaryPath) {
+                cliLogger.warn('Splice binary not found (skipping distributed functions)');
+                return;
+            }
+            // 2. Build user server
+            const userServerPath = await buildUserServer(this.config.projectDir);
+            if (!userServerPath) {
+                cliLogger.warn('User server build failed (skipping Splice)');
+                return;
+            }
+            this.userServerBinaryPath = userServerPath;
+            // 3. Generate socket path for Splice
+            this.splicePath = path.join(tmpdir(), `splice-dev-${Date.now()}-${Math.random().toString(36).substring(7)}.sock`);
+            // 4. Create and start Splice manager
+            this.spliceManager = new SpliceManager({
+                spliceBinaryPath,
+                workerBinaryPath: userServerPath,
+                socketPath: this.splicePath,
+                maxConcurrency: 1024,
+                timeout: 30,
+                watchPaths: [path.join(this.config.projectDir, 'server')],
+            });
+            await this.spliceManager.start();
+            cliLogger.succeedSpinner('splice', `Splice ready on ${this.splicePath}`);
+            // Generate initial TypeScript bindings from Splice exports
+            cliLogger.spinner('splice-codegen', 'Generating TypeScript bindings...');
+            await this.runSpliceCodegen();
+            cliLogger.succeedSpinner('splice-codegen', 'Splice bindings generated');
+        }
+        catch (err) {
+            cliLogger.failSpinner('splice', 'Failed to start Splice');
+            const message = err instanceof Error ? err.message : String(err);
+            this.log('error', `Splice error: ${message}`);
+            // Don't throw - continue without Splice
+        }
     }
     /**
      * Restart Rust server (called when routes change)
@@ -600,6 +670,126 @@ export class DevServer extends EventEmitter {
             await this.viteProxy.restart();
         }
     }
+    /**
+     * Handle user server (server/ Rust files) file changes
+     */
+    async handleUserServerChange(event) {
+        const relativePath = path.relative(this.config.projectDir, event.path);
+        cliLogger.newline();
+        cliLogger.info(`[user-server:${event.type}] ${relativePath}`);
+        // Only proceed if Splice is running
+        if (!this.spliceManager?.isRunning()) {
+            this.log('debug', 'Splice not running, skipping user server rebuild');
+            return;
+        }
+        cliLogger.spinner('user-server-rebuild', 'Rebuilding user server...');
+        const rebuildStart = Date.now();
+        try {
+            // Step 1: Rebuild user server binary
+            const newBinaryPath = await buildUserServer(this.config.projectDir);
+            if (!newBinaryPath) {
+                cliLogger.failSpinner('user-server-rebuild', 'User server build failed');
+                this.hotReloadServer.notifyError('User server compilation failed');
+                return;
+            }
+            this.userServerBinaryPath = newBinaryPath;
+            const duration = ((Date.now() - rebuildStart) / 1000).toFixed(2);
+            cliLogger.succeedSpinner('user-server-rebuild', `User server rebuilt (${duration}s)`);
+            // Step 2: Wait for Splice to detect binary change and reload worker
+            this.log('info', 'Waiting for Splice to reload worker...');
+            await this.waitForSpliceReload();
+            // Step 3: Regenerate TypeScript bindings from updated exports
+            if (this.splicePath) {
+                cliLogger.spinner('splice-codegen', 'Regenerating Splice bindings...');
+                await this.runSpliceCodegen();
+                cliLogger.succeedSpinner('splice-codegen', 'TypeScript bindings updated');
+            }
+            // Step 4: Signal browser to reload
+            this.hotReloadServer.reload('rust', [relativePath]);
+            this.state.phase = 'ready';
+        }
+        catch (err) {
+            cliLogger.failSpinner('user-server-rebuild', 'Rebuild failed');
+            const message = err instanceof Error ? err.message : String(err);
+            this.log('error', `User server rebuild error: ${message}`);
+            this.hotReloadServer.notifyError(`User server error: ${message}`);
+            this.state.phase = 'error';
+        }
+    }
+    /**
+     * Wait for Splice to detect binary change and reload
+     */
+    async waitForSpliceReload() {
+        // Splice ReloadManager detects binary hash change and auto-reloads
+        // Give it time to complete the reload cycle
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    /**
+     * Run Splice codegen to generate TypeScript bindings
+     */
+    async runSpliceCodegen() {
+        if (!this.splicePath || !this.spliceManager?.isRunning()) {
+            throw new Error('Splice not running');
+        }
+        const codegenBinary = await this.findCodegenBinary();
+        if (!codegenBinary) {
+            throw new Error('Codegen binary not found');
+        }
+        return new Promise((resolve, reject) => {
+            const args = ['--splice-socket', this.splicePath, '--output-dir', './src/api'];
+            this.log('debug', `Running codegen: ${codegenBinary} ${args.join(' ')}`);
+            const proc = spawn(codegenBinary, args, {
+                cwd: this.config.projectDir,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let stderr = '';
+            proc.stdout?.on('data', (data) => {
+                this.log('debug', `[codegen] ${data.toString().trim()}`);
+            });
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+                this.log('warn', `[codegen] ${data.toString().trim()}`);
+            });
+            proc.on('close', (code) => {
+                if (code === 0) {
+                    this.log('info', 'Splice codegen completed successfully');
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Codegen exited with code ${code}: ${stderr}`));
+                }
+            });
+            proc.on('error', (err) => {
+                reject(new Error(`Codegen process error: ${err.message}`));
+            });
+        });
+    }
+    /**
+     * Find codegen binary in various locations
+     */
+    async findCodegenBinary() {
+        const candidates = [
+            this.config.codegenBinaryPath,
+            path.join(this.config.projectDir, 'bin/zap-codegen'),
+            path.join(__dirname, '../../bin/zap-codegen'),
+            path.join(this.config.projectDir, 'node_modules/@zap-js/client/bin/zap-codegen'),
+            path.join(this.config.projectDir, 'target/release/zap-codegen'),
+            path.join(this.config.projectDir, 'target/debug/zap-codegen'),
+        ].filter(Boolean);
+        for (const candidate of candidates) {
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        // Check PATH
+        try {
+            execSync('which zap-codegen', { stdio: 'ignore' });
+            return 'zap-codegen';
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Print the ready message
      */

package/dist/dev-server/splice-manager.d.ts

@@ -0,0 +1,52 @@
+import { EventEmitter } from 'events';
+export interface SpliceManagerConfig {
+    /** Path to Splice binary */
+    spliceBinaryPath: string;
+    /** Path to user's server binary */
+    workerBinaryPath: string;
+    /** Socket path for host connection */
+    socketPath: string;
+    /** Max concurrent requests */
+    maxConcurrency?: number;
+    /** Timeout in seconds */
+    timeout?: number;
+    /** Watch paths for hot reload */
+    watchPaths?: string[];
+}
+/**
+ * SpliceManager - DevServer component for Splice supervisor
+ *
+ * Manages the Splice process lifecycle:
+ * - Spawns splice binary with proper args
+ * - Forwards logs
+ * - Monitors health
+ * - Graceful shutdown
+ *
+ * Follows same pattern as ProcessManager but specialized for Splice
+ */
+export declare class SpliceManager extends EventEmitter {
+    private config;
+    private process;
+    private running;
+    constructor(config: SpliceManagerConfig);
+    /**
+     * Start the Splice supervisor
+     */
+    start(): Promise<void>;
+    /**
+     * Wait for Splice to create its socket file
+     */
+    private waitForSocket;
+    /**
+     * Stop the Splice process
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if Splice is running
+     */
+    isRunning(): boolean;
+    /**
+     * Get the socket path
+     */
+    getSocketPath(): string;
+}

package/dist/dev-server/splice-manager.js

@@ -0,0 +1,146 @@
+import { EventEmitter } from 'events';
+import { spawn } from 'child_process';
+import { existsSync, unlinkSync } from 'fs';
+/**
+ * SpliceManager - DevServer component for Splice supervisor
+ *
+ * Manages the Splice process lifecycle:
+ * - Spawns splice binary with proper args
+ * - Forwards logs
+ * - Monitors health
+ * - Graceful shutdown
+ *
+ * Follows same pattern as ProcessManager but specialized for Splice
+ */
+export class SpliceManager extends EventEmitter {
+    constructor(config) {
+        super();
+        this.process = null;
+        this.running = false;
+        this.config = config;
+    }
+    /**
+     * Start the Splice supervisor
+     */
+    async start() {
+        if (this.running) {
+            throw new Error('Splice already running');
+        }
+        const args = [
+            '--socket',
+            this.config.socketPath,
+            '--worker',
+            this.config.workerBinaryPath,
+            '--max-concurrency',
+            (this.config.maxConcurrency || 1024).toString(),
+            '--timeout',
+            (this.config.timeout || 30).toString(),
+        ];
+        if (this.config.watchPaths && this.config.watchPaths.length > 0) {
+            args.push('--watch', this.config.watchPaths.join(','));
+        }
+        console.log('[Splice] Starting supervisor...');
+        console.log('[Splice] Worker:', this.config.workerBinaryPath);
+        console.log('[Splice] Socket:', this.config.socketPath);
+        this.process = spawn(this.config.spliceBinaryPath, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                RUST_LOG: process.env.RUST_LOG || 'info',
+            },
+        });
+        if (!this.process.stdout || !this.process.stderr) {
+            throw new Error('Failed to create Splice process streams');
+        }
+        // Forward stdout
+        this.process.stdout.on('data', (data) => {
+            const output = data.toString().trim();
+            if (output) {
+                console.log(`[Splice] ${output}`);
+            }
+        });
+        // Forward stderr
+        this.process.stderr.on('data', (data) => {
+            const output = data.toString().trim();
+            if (output) {
+                console.error(`[Splice] ${output}`);
+            }
+        });
+        // Handle exit
+        this.process.on('exit', (code, signal) => {
+            this.running = false;
+            if (code !== 0 && code !== null) {
+                console.error(`[Splice] Exited: code=${code}, signal=${signal}`);
+                this.emit('error', new Error(`Splice exited with code ${code}`));
+            }
+        });
+        // Handle errors
+        this.process.on('error', (err) => {
+            this.running = false;
+            console.error('[Splice] Process error:', err);
+            this.emit('error', err);
+        });
+        this.running = true;
+        this.emit('started');
+        // Wait for socket to be ready
+        await this.waitForSocket();
+    }
+    /**
+     * Wait for Splice to create its socket file
+     */
+    async waitForSocket() {
+        const maxWait = 5000; // 5 seconds
+        const checkInterval = 100;
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxWait) {
+            if (existsSync(this.config.socketPath)) {
+                console.log('[Splice] Socket ready');
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, checkInterval));
+        }
+        throw new Error('Splice socket not ready within timeout');
+    }
+    /**
+     * Stop the Splice process
+     */
+    async stop() {
+        if (!this.process || !this.running) {
+            return;
+        }
+        console.log('[Splice] Stopping...');
+        if (!this.process.killed) {
+            this.process.kill('SIGTERM');
+        }
+        // Wait briefly for graceful shutdown
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        // Force kill if still running
+        if (!this.process.killed) {
+            this.process.kill('SIGKILL');
+        }
+        this.process = null;
+        this.running = false;
+        // Cleanup socket file
+        if (existsSync(this.config.socketPath)) {
+            try {
+                unlinkSync(this.config.socketPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        this.emit('stopped');
+    }
+    /**
+     * Check if Splice is running
+     */
+    isRunning() {
+        return this.running && this.process !== null && !this.process.killed;
+    }
+    /**
+     * Get the socket path
+     */
+    getSocketPath() {
+        return this.config.socketPath;
+    }
+}

package/dist/dev-server/watcher.d.ts

@@ -3,7 +3,7 @@ export type WatchEventType = 'add' | 'change' | 'unlink';
 export interface WatchEvent {
     type: WatchEventType;
     path: string;
-    category: 'rust' | 'typescript' | 'config' | 'unknown';
+    category: 'rust' | 'user-server' | 'typescript' | 'config' | 'unknown';
 }
 export interface WatcherConfig {
     rootDir: string;
@@ -38,7 +38,7 @@ export declare class FileWatcher extends EventEmitter {
      */
     private handleEvent;
     /**
-     * Categorize a file based on its extension
+     * Categorize a file based on its extension and location
      */
     private categorizeFile;
     /**

package/dist/dev-server/watcher.js

@@ -98,12 +98,19 @@ export class FileWatcher extends EventEmitter {
         this.debounceTimers.set(filePath, timer);
     }
     /**
-     * Categorize a file based on its extension
+     * Categorize a file based on its extension and location
      */
     categorizeFile(filePath) {
         const ext = path.extname(filePath).toLowerCase();
         const basename = path.basename(filePath);
-        // Rust files
+        // Check if file is in server/ directory (user's Rust server)
+        const relativePath = path.relative(this.config.rootDir, filePath);
+        if (relativePath.startsWith('server' + path.sep) || relativePath === 'server') {
+            if (ext === '.rs' || basename === 'Cargo.toml') {
+                return 'user-server';
+            }
+        }
+        // Rust files in packages/server (Zap runtime)
         if (ext === '.rs' || basename === 'Cargo.toml') {
             return 'rust';
         }

package/dist/runtime/types.d.ts

@@ -360,6 +360,8 @@ export interface ZapConfig {
     security?: SecurityConfig;
     /** Observability configuration */
     observability?: ObservabilityConfig;
+    /** Splice socket path for distributed Rust functions (optional) */
+    splice_socket_path?: string;
 }
 /**
  * Type guard for InvokeHandlerMessage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-js/client",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "High-performance fullstack React framework - Client package",
   "homepage": "https://github.com/saint0x/zapjs",
   "repository": {
@@ -74,9 +74,9 @@
     "ws": "^8.16.0"
   },
   "optionalDependencies": {
-    "@zap-js/darwin-arm64": "0.2.1",
-    "@zap-js/darwin-x64": "0.2.1",
-    "@zap-js/linux-x64": "0.2.1"
+    "@zap-js/darwin-arm64": "0.2.3",
+    "@zap-js/darwin-x64": "0.2.3",
+    "@zap-js/linux-x64": "0.2.3"
   },
   "peerDependencies": {
     "react": "^18.0.0",