@spfn/core 0.1.0-alpha.64 → 0.1.0-alpha.68

package/dist/server/index.js

@@ -128,11 +128,11 @@ function formatTimestampHuman(date) {
   const ms = String(date.getMilliseconds()).padStart(3, "0");
   return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
 }
-function formatError(error) {
+function formatError(error2) {
   const lines = [];
-  lines.push(`${error.name}: ${error.message}`);
-  if (error.stack) {
-    const stackLines = error.stack.split("\n").slice(1);
+  lines.push(`${error2.name}: ${error2.message}`);
+  if (error2.stack) {
+    const stackLines = error2.stack.split("\n").slice(1);
     lines.push(...stackLines);
   }
   return lines.join("\n");
@@ -318,7 +318,7 @@ var init_logger = __esm({
       /**
        * Log processing (internal)
        */
-      log(level, message, error, context) {
+      log(level, message, error2, context) {
         if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.config.level]) {
           return;
         }
@@ -327,7 +327,7 @@ var init_logger = __esm({
           level,
           message,
           module: this.module,
-          error,
+          error: error2,
           // Mask sensitive information in context to prevent credential leaks
           context: context ? maskSensitiveData(context) : void 0
         };
@@ -338,8 +338,8 @@ var init_logger = __esm({
        */
       processTransports(metadata) {
         const promises = this.config.transports.filter((transport) => transport.enabled).map((transport) => this.safeTransportLog(transport, metadata));
-        Promise.all(promises).catch((error) => {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+        Promise.all(promises).catch((error2) => {
+          const errorMessage = error2 instanceof Error ? error2.message : String(error2);
           process.stderr.write(`[Logger] Transport error: ${errorMessage}
 `);
         });
@@ -350,8 +350,8 @@ var init_logger = __esm({
       async safeTransportLog(transport, metadata) {
         try {
           await transport.log(metadata);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+        } catch (error2) {
+          const errorMessage = error2 instanceof Error ? error2.message : String(error2);
           process.stderr.write(`[Logger] Transport "${transport.name}" failed: ${errorMessage}
 `);
         }
@@ -441,11 +441,11 @@ var init_file = __esm({
         }
         if (this.currentStream) {
           return new Promise((resolve, reject) => {
-            this.currentStream.write(message + "\n", "utf-8", (error) => {
-              if (error) {
-                process.stderr.write(`[FileTransport] Failed to write log: ${error.message}
+            this.currentStream.write(message + "\n", "utf-8", (error2) => {
+              if (error2) {
+                process.stderr.write(`[FileTransport] Failed to write log: ${error2.message}
 `);
-                reject(error);
+                reject(error2);
               } else {
                 resolve();
               }
@@ -467,8 +467,8 @@ var init_file = __esm({
           encoding: "utf-8"
         });
         this.currentFilename = filename;
-        this.currentStream.on("error", (error) => {
-          process.stderr.write(`[FileTransport] Stream error: ${error.message}
+        this.currentStream.on("error", (error2) => {
+          process.stderr.write(`[FileTransport] Stream error: ${error2.message}
 `);
           this.currentStream = null;
           this.currentFilename = null;
@@ -482,9 +482,9 @@ var init_file = __esm({
           return;
         }
         return new Promise((resolve, reject) => {
-          this.currentStream.end((error) => {
-            if (error) {
-              reject(error);
+          this.currentStream.end((error2) => {
+            if (error2) {
+              reject(error2);
             } else {
               this.currentStream = null;
               this.currentFilename = null;
@@ -509,8 +509,8 @@ var init_file = __esm({
           if (stats.size >= this.maxFileSize) {
             await this.rotateBySize();
           }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+        } catch (error2) {
+          const errorMessage = error2 instanceof Error ? error2.message : String(error2);
           process.stderr.write(`[FileTransport] Failed to check file size: ${errorMessage}
 `);
         }
@@ -536,8 +536,8 @@ var init_file = __esm({
             const newPath2 = join(this.logDir, `${baseName}.${newNum}.log`);
             try {
               renameSync(oldPath, newPath2);
-            } catch (error) {
-              const errorMessage = error instanceof Error ? error.message : String(error);
+            } catch (error2) {
+              const errorMessage = error2 instanceof Error ? error2.message : String(error2);
               process.stderr.write(`[FileTransport] Failed to rotate file: ${errorMessage}
 `);
             }
@@ -549,8 +549,8 @@ var init_file = __esm({
           if (existsSync(currentPath)) {
             renameSync(currentPath, newPath);
           }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+        } catch (error2) {
+          const errorMessage = error2 instanceof Error ? error2.message : String(error2);
           process.stderr.write(`[FileTransport] Failed to rotate current file: ${errorMessage}
 `);
         }
@@ -577,15 +577,15 @@ var init_file = __esm({
               const filepath = join(this.logDir, file);
               try {
                 unlinkSync(filepath);
-              } catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
+              } catch (error2) {
+                const errorMessage = error2 instanceof Error ? error2.message : String(error2);
                 process.stderr.write(`[FileTransport] Failed to delete old file "${file}": ${errorMessage}
 `);
               }
             }
           }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+        } catch (error2) {
+          const errorMessage = error2 instanceof Error ? error2.message : String(error2);
           process.stderr.write(`[FileTransport] Failed to clean old files: ${errorMessage}
 `);
         }
@@ -644,8 +644,8 @@ function validateDirectoryWritable(dirPath) {
   if (!existsSync(dirPath)) {
     try {
       mkdirSync(dirPath, { recursive: true });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
+    } catch (error2) {
+      const errorMessage = error2 instanceof Error ? error2.message : String(error2);
       throw new Error(`Failed to create log directory "${dirPath}": ${errorMessage}`);
     }
   }
@@ -658,8 +658,8 @@ function validateDirectoryWritable(dirPath) {
   try {
     writeFileSync(testFile, "test", "utf-8");
     unlinkSync(testFile);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
+  } catch (error2) {
+    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
     throw new Error(`Cannot write to log directory "${dirPath}": ${errorMessage}`);
   }
 }
@@ -736,11 +736,11 @@ function validateConfig() {
     validateFileConfig();
     validateSlackConfig();
     validateEmailConfig();
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`[Logger] Configuration validation failed: ${error.message}`);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw new Error(`[Logger] Configuration validation failed: ${error2.message}`);
     }
-    throw error;
+    throw error2;
   }
 }
 var init_config = __esm({
@@ -878,24 +878,28 @@ function discoverFunctionRoutes(cwd = process.cwd()) {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
         if (pkg.spfn?.routes?.dir) {
           const { dir } = pkg.spfn.routes;
+          const prefix = pkg.spfn.prefix;
           const packagePath = dirname(pkgPath);
           const routesDir = join(packagePath, dir);
           functions.push({
             packageName,
             routesDir,
-            packagePath
+            packagePath,
+            prefix
+            // Include prefix in function info
           });
           routeLogger.debug("Discovered function routes", {
             package: packageName,
-            dir
+            dir,
+            prefix: prefix || "(none)"
           });
         }
-      } catch (error) {
+      } catch (error2) {
       }
     }
-  } catch (error) {
+  } catch (error2) {
     routeLogger.warn("Failed to discover function routes", {
-      error: error instanceof Error ? error.message : "Unknown error"
+      error: error2 instanceof Error ? error2.message : "Unknown error"
     });
   }
   return functions;
@@ -909,7 +913,7 @@ var init_function_routes = __esm({
 });
 
 // src/errors/database-errors.ts
-var DatabaseError, ConnectionError, QueryError, ValidationError, TransactionError, DeadlockError, DuplicateEntryError;
+var DatabaseError, ConnectionError, QueryError, ConstraintViolationError, TransactionError, DeadlockError, DuplicateEntryError;
 var init_database_errors = __esm({
   "src/errors/database-errors.ts"() {
     DatabaseError = class extends Error {
@@ -949,10 +953,10 @@ var init_database_errors = __esm({
         this.name = "QueryError";
       }
     };
-    ValidationError = class extends QueryError {
+    ConstraintViolationError = class extends QueryError {
       constructor(message, details) {
         super(message, 400, details);
-        this.name = "ValidationError";
+        this.name = "ConstraintViolationError";
       }
     };
     TransactionError = class extends DatabaseError {
@@ -1072,8 +1076,8 @@ function loadSingleFile(filePath, debug) {
       });
     }
     return { success: true, parsed };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : "Unknown error";
     envLogger.error("Error loading environment file", {
       path: filePath,
       error: message
@@ -1089,12 +1093,12 @@ function validateRequiredVars(required, debug) {
     }
   }
   if (missing.length > 0) {
-    const error = `Required environment variables missing: ${missing.join(", ")}`;
+    const error2 = `Required environment variables missing: ${missing.join(", ")}`;
     envLogger.error("Environment validation failed", {
       missing,
       required
     });
-    throw new Error(error);
+    throw new Error(error2);
   }
   if (debug) {
     envLogger.debug("Required environment variables validated", {
@@ -1175,12 +1179,12 @@ function loadEnvironment(options = {}) {
   if (required.length > 0) {
     try {
       validateRequiredVars(required, debug);
-    } catch (error) {
+    } catch (error2) {
       result.success = false;
       result.errors = [
-        error instanceof Error ? error.message : "Validation failed"
+        error2 instanceof Error ? error2.message : "Validation failed"
       ];
-      throw error;
+      throw error2;
     }
   }
   if (result.warnings.length > 0) {
@@ -1237,9 +1241,9 @@ function parseUniqueViolation(message) {
   }
   return null;
 }
-function fromPostgresError(error) {
-  const code = error?.code;
-  const message = error?.message || "Database error occurred";
+function fromPostgresError(error2) {
+  const code = error2?.code;
+  const message = error2?.message || "Database error occurred";
   switch (code) {
     // Class 08 — Connection Exception
     case "08000":
@@ -1260,11 +1264,11 @@ function fromPostgresError(error) {
     case "23000":
     // integrity_constraint_violation
     case "23001":
-      return new ValidationError(message, { code, constraint: "integrity" });
+      return new ConstraintViolationError(message, { code, constraint: "integrity" });
     case "23502":
-      return new ValidationError(message, { code, constraint: "not_null" });
+      return new ConstraintViolationError(message, { code, constraint: "not_null" });
     case "23503":
-      return new ValidationError(message, { code, constraint: "foreign_key" });
+      return new ConstraintViolationError(message, { code, constraint: "foreign_key" });
     case "23505":
       const parsed = parseUniqueViolation(message);
       if (parsed) {
@@ -1272,7 +1276,7 @@ function fromPostgresError(error) {
       }
       return new DuplicateEntryError("field", "value");
     case "23514":
-      return new ValidationError(message, { code, constraint: "check" });
+      return new ConstraintViolationError(message, { code, constraint: "check" });
     // Class 40 — Transaction Rollback
     case "40000":
     // transaction_rollback
@@ -1355,8 +1359,8 @@ async function createDatabaseConnection(connectionString, poolConfig, retryConfi
         dbLogger.info("Database connected successfully");
       }
       return client;
-    } catch (error) {
-      lastError = fromPostgresError(error);
+    } catch (error2) {
+      lastError = fromPostgresError(error2);
       if (attempt < retryConfig.maxRetries) {
         const delayMs = Math.min(
           retryConfig.initialDelay * Math.pow(retryConfig.factor, attempt),
@@ -1382,8 +1386,8 @@ async function checkConnection(client) {
   try {
     await client`SELECT 1 as health_check`;
     return true;
-  } catch (error) {
-    dbLogger.error("Database health check failed", error);
+  } catch (error2) {
+    dbLogger.error("Database health check failed", error2);
     return false;
   }
 }
@@ -1553,8 +1557,8 @@ async function createDatabaseFromEnv(options) {
         dbLogger2.warn("No database pattern detected");
         return { write: void 0, read: void 0 };
     }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : "Unknown error";
     dbLogger2.error("Failed to create database connection", {
       error: message,
       stage: "initialization",
@@ -1563,7 +1567,7 @@ async function createDatabaseFromEnv(options) {
       hasUrl: !!process.env.DATABASE_URL,
       hasReplicaUrl: !!process.env.DATABASE_REPLICA_URL
     });
-    throw new Error(`Database connection failed: ${message}`, { cause: error });
+    throw new Error(`Database connection failed: ${message}`, { cause: error2 });
   }
 }
 var dbLogger2;
@@ -1628,8 +1632,8 @@ function startHealthCheck(config, options, getDatabase2, closeDatabase2) {
       if (read && read !== write) {
         await read.execute("SELECT 1");
       }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : "Unknown error";
       dbLogger3.error("Database health check failed", { error: message });
       if (config.reconnect) {
         await attemptReconnection(config, options, closeDatabase2);
@@ -1658,8 +1662,8 @@ async function attemptReconnection(config, options, closeDatabase2) {
         dbLogger3.info("Database reconnection successful", { attempt });
         return;
       }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : "Unknown error";
       dbLogger3.error(`Reconnection attempt ${attempt} failed`, {
         error: message,
         attempt,
@@ -1736,11 +1740,11 @@ async function initDatabase(options) {
           logQueries: monConfig.logQueries
         });
       }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : "Unknown error";
       dbLogger4.error("Database connection failed", { error: message });
       await closeDatabase();
-      throw new Error(`Database connection test failed: ${message}`, { cause: error });
+      throw new Error(`Database connection test failed: ${message}`, { cause: error2 });
     }
   } else {
     dbLogger4.warn("No database configuration found");
@@ -1774,9 +1778,9 @@ async function closeDatabase() {
     }
     await Promise.all(closePromises);
     dbLogger4.info("All database connections closed");
-  } catch (error) {
-    dbLogger4.error("Error during database cleanup", error);
-    throw error;
+  } catch (error2) {
+    dbLogger4.error("Error during database cleanup", error2);
+    throw error2;
   } finally {
     setWriteInstance(void 0);
     setReadInstance(void 0);
@@ -1882,7 +1886,7 @@ function discoverPackageSchemas(cwd) {
         ...Object.keys(projectPkg.dependencies || {}),
         ...Object.keys(projectPkg.devDependencies || {})
       ]);
-    } catch (error) {
+    } catch (error2) {
     }
   }
   const checkPackage = (_pkgName, pkgPath) => {
@@ -1901,7 +1905,7 @@ function discoverPackageSchemas(cwd) {
           schemas.push(...schemaFiles);
         }
       }
-    } catch (error) {
+    } catch (error2) {
     }
   };
   const spfnDir = join(nodeModulesPath, "@spfn");
@@ -1911,7 +1915,7 @@ function discoverPackageSchemas(cwd) {
       for (const pkg of spfnPackages) {
         checkPackage(`@spfn/${pkg}`, join(spfnDir, pkg));
       }
-    } catch (error) {
+    } catch (error2) {
     }
   }
   for (const depName of directDeps) {
@@ -2155,9 +2159,9 @@ function Transactional(options = {}) {
           });
         }
       }
-    } catch (error) {
+    } catch (error2) {
       const duration = Date.now() - startTime;
-      const customError = error instanceof TransactionError ? error : fromPostgresError(error);
+      const customError = error2 instanceof TransactionError ? error2 : fromPostgresError(error2);
       if (enableLogging) {
         txLogger2.error("Transaction rolled back", {
           txId,
@@ -2379,110 +2383,149 @@ var init_db = __esm({
   }
 });
 
-// src/cache/redis-factory.ts
-function hasRedisConfig() {
-  return !!(process.env.REDIS_URL || process.env.REDIS_WRITE_URL || process.env.REDIS_READ_URL || process.env.REDIS_SENTINEL_HOSTS || process.env.REDIS_CLUSTER_NODES);
+// src/cache/cache-factory.ts
+function hasCacheConfig() {
+  return !!// Modern (Valkey/Cache)
+  (process.env.VALKEY_URL || process.env.CACHE_URL || process.env.VALKEY_WRITE_URL || process.env.VALKEY_READ_URL || process.env.CACHE_WRITE_URL || process.env.CACHE_READ_URL || process.env.VALKEY_SENTINEL_HOSTS || process.env.VALKEY_CLUSTER_NODES || // Legacy (Redis - backward compatibility)
+  process.env.REDIS_URL || process.env.REDIS_WRITE_URL || process.env.REDIS_READ_URL || process.env.REDIS_SENTINEL_HOSTS || process.env.REDIS_CLUSTER_NODES);
+}
+function getEnv(valkeyKey, cacheKey, redisKey) {
+  return process.env[valkeyKey] || process.env[cacheKey] || process.env[redisKey];
 }
 function createClient(RedisClient, url) {
   const options = {};
-  if (url.startsWith("rediss://")) {
+  if (url.startsWith("rediss://") || url.startsWith("valkeys://")) {
+    const rejectUnauthorized = getEnv(
+      "VALKEY_TLS_REJECT_UNAUTHORIZED",
+      "CACHE_TLS_REJECT_UNAUTHORIZED",
+      "REDIS_TLS_REJECT_UNAUTHORIZED"
+    );
     options.tls = {
-      rejectUnauthorized: process.env.REDIS_TLS_REJECT_UNAUTHORIZED !== "false"
+      rejectUnauthorized: rejectUnauthorized !== "false"
     };
   }
   return new RedisClient(url, options);
 }
-async function createRedisFromEnv() {
-  if (!hasRedisConfig()) {
+async function createCacheFromEnv() {
+  if (!hasCacheConfig()) {
+    cacheLogger.info("No cache configuration found - running without cache");
     return { write: void 0, read: void 0 };
   }
   try {
     const ioredis = await import('ioredis');
     const RedisClient = ioredis.default;
-    if (process.env.REDIS_URL && !process.env.REDIS_WRITE_URL && !process.env.REDIS_READ_URL && !process.env.REDIS_CLUSTER_NODES) {
-      const client = createClient(RedisClient, process.env.REDIS_URL);
+    const singleUrl = getEnv("VALKEY_URL", "CACHE_URL", "REDIS_URL");
+    const writeUrl = getEnv("VALKEY_WRITE_URL", "CACHE_WRITE_URL", "REDIS_WRITE_URL");
+    const readUrl = getEnv("VALKEY_READ_URL", "CACHE_READ_URL", "REDIS_READ_URL");
+    const clusterNodes = getEnv("VALKEY_CLUSTER_NODES", "CACHE_CLUSTER_NODES", "REDIS_CLUSTER_NODES");
+    const sentinelHosts = getEnv("VALKEY_SENTINEL_HOSTS", "CACHE_SENTINEL_HOSTS", "REDIS_SENTINEL_HOSTS");
+    const masterName = getEnv("VALKEY_MASTER_NAME", "CACHE_MASTER_NAME", "REDIS_MASTER_NAME");
+    const password = getEnv("VALKEY_PASSWORD", "CACHE_PASSWORD", "REDIS_PASSWORD");
+    if (singleUrl && !writeUrl && !readUrl && !clusterNodes) {
+      const client = createClient(RedisClient, singleUrl);
+      cacheLogger.debug("Created single cache instance", { url: singleUrl.replace(/:[^:@]+@/, ":***@") });
       return { write: client, read: client };
     }
-    if (process.env.REDIS_WRITE_URL && process.env.REDIS_READ_URL) {
-      const write = createClient(RedisClient, process.env.REDIS_WRITE_URL);
-      const read = createClient(RedisClient, process.env.REDIS_READ_URL);
+    if (writeUrl && readUrl) {
+      const write = createClient(RedisClient, writeUrl);
+      const read = createClient(RedisClient, readUrl);
+      cacheLogger.debug("Created master-replica cache instances");
       return { write, read };
     }
-    if (process.env.REDIS_SENTINEL_HOSTS && process.env.REDIS_MASTER_NAME) {
-      const sentinels = process.env.REDIS_SENTINEL_HOSTS.split(",").map((host) => {
+    if (sentinelHosts && masterName) {
+      const sentinels = sentinelHosts.split(",").map((host) => {
         const [hostname, port] = host.trim().split(":");
         return { host: hostname, port: Number(port) || 26379 };
       });
       const options = {
         sentinels,
-        name: process.env.REDIS_MASTER_NAME,
-        password: process.env.REDIS_PASSWORD
+        name: masterName,
+        password
       };
       const client = new RedisClient(options);
+      cacheLogger.debug("Created sentinel cache instance", { masterName, sentinels: sentinels.length });
       return { write: client, read: client };
     }
-    if (process.env.REDIS_CLUSTER_NODES) {
-      const nodes = process.env.REDIS_CLUSTER_NODES.split(",").map((node) => {
+    if (clusterNodes) {
+      const nodes = clusterNodes.split(",").map((node) => {
         const [host, port] = node.trim().split(":");
         return { host, port: Number(port) || 6379 };
       });
       const clusterOptions = {
         redisOptions: {
-          password: process.env.REDIS_PASSWORD
+          password
         }
       };
       const cluster = new RedisClient.Cluster(nodes, clusterOptions);
+      cacheLogger.debug("Created cluster cache instance", { nodes: nodes.length });
       return { write: cluster, read: cluster };
     }
-    if (process.env.REDIS_URL) {
-      const client = createClient(RedisClient, process.env.REDIS_URL);
+    if (singleUrl) {
+      const client = createClient(RedisClient, singleUrl);
+      cacheLogger.debug("Created cache instance (fallback)", { url: singleUrl.replace(/:[^:@]+@/, ":***@") });
       return { write: client, read: client };
     }
+    cacheLogger.info("No valid cache configuration found - running without cache");
     return { write: void 0, read: void 0 };
-  } catch (error) {
-    if (error instanceof Error) {
-      cacheLogger.warn(
-        "Failed to create Redis client",
-        error,
-        { suggestion: "Using memory-only cache. Install ioredis: npm install ioredis" }
-      );
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      if (error2.message.includes("Cannot find module")) {
+        cacheLogger.warn(
+          "Cache client library not installed",
+          error2,
+          {
+            suggestion: "Install ioredis to enable cache: pnpm install ioredis",
+            mode: "disabled"
+          }
+        );
+      } else {
+        cacheLogger.warn(
+          "Failed to create cache client",
+          error2,
+          { mode: "disabled" }
+        );
+      }
     } else {
       cacheLogger.warn(
-        "Failed to create Redis client",
-        { error: String(error), suggestion: "Using memory-only cache. Install ioredis: npm install ioredis" }
+        "Failed to create cache client",
+        { error: String(error2), mode: "disabled" }
       );
     }
     return { write: void 0, read: void 0 };
   }
 }
-async function createSingleRedisFromEnv() {
-  const { write } = await createRedisFromEnv();
+async function createSingleCacheFromEnv() {
+  const { write } = await createCacheFromEnv();
   return write;
 }
 var cacheLogger;
-var init_redis_factory = __esm({
-  "src/cache/redis-factory.ts"() {
+var init_cache_factory = __esm({
+  "src/cache/cache-factory.ts"() {
     init_logger2();
     cacheLogger = logger.child("cache");
   }
 });
 
-// src/cache/redis-manager.ts
-function getRedis() {
+// src/cache/cache-manager.ts
+function getCache() {
   return writeInstance;
 }
-function getRedisRead() {
+function getCacheRead() {
   return readInstance ?? writeInstance;
 }
-function setRedis(write, read) {
+function isCacheDisabled() {
+  return isDisabled;
+}
+function setCache(write, read) {
   writeInstance = write;
   readInstance = read ?? write;
+  isDisabled = !write;
 }
-async function initRedis() {
+async function initCache() {
   if (writeInstance) {
-    return { write: writeInstance, read: readInstance };
+    return { write: writeInstance, read: readInstance, disabled: isDisabled };
   }
-  const { write, read } = await createRedisFromEnv();
+  const { write, read } = await createCacheFromEnv();
   if (write) {
     try {
       await write.ping();
@@ -2491,14 +2534,18 @@ async function initRedis() {
       }
       writeInstance = write;
       readInstance = read;
+      isDisabled = false;
       const hasReplica = read && read !== write;
       cacheLogger2.info(
-        hasReplica ? "Redis connected (Master-Replica)" : "Redis connected"
+        hasReplica ? "Cache connected (Master-Replica)" : "Cache connected",
+        { mode: "enabled" }
       );
-    } catch (error) {
+      return { write: writeInstance, read: readInstance, disabled: false };
+    } catch (error2) {
       cacheLogger2.error(
-        "Redis connection failed",
-        error instanceof Error ? error : new Error(String(error))
+        "Cache connection failed - running in disabled mode",
+        error2 instanceof Error ? error2 : new Error(String(error2)),
+        { mode: "disabled" }
       );
       try {
         await write.quit();
@@ -2507,64 +2554,91 @@ async function initRedis() {
         }
       } catch {
       }
-      return { write: void 0, read: void 0 };
+      isDisabled = true;
+      return { write: void 0, read: void 0, disabled: true };
     }
   }
-  return { write: writeInstance, read: readInstance };
+  isDisabled = true;
+  cacheLogger2.info("Cache disabled - no configuration or library not installed", { mode: "disabled" });
+  return { write: void 0, read: void 0, disabled: true };
 }
-async function closeRedis() {
+async function closeCache() {
+  if (isDisabled) {
+    cacheLogger2.debug("Cache already disabled, nothing to close");
+    return;
+  }
   const closePromises = [];
   if (writeInstance) {
     closePromises.push(
       writeInstance.quit().catch((err) => {
-        cacheLogger2.error("Error closing Redis write instance", err);
+        cacheLogger2.error("Error closing cache write instance", err);
       })
     );
   }
   if (readInstance && readInstance !== writeInstance) {
     closePromises.push(
       readInstance.quit().catch((err) => {
-        cacheLogger2.error("Error closing Redis read instance", err);
+        cacheLogger2.error("Error closing cache read instance", err);
       })
     );
   }
   await Promise.all(closePromises);
   writeInstance = void 0;
   readInstance = void 0;
-  cacheLogger2.info("Redis connections closed");
+  isDisabled = true;
+  cacheLogger2.info("Cache connections closed", { mode: "disabled" });
 }
-function getRedisInfo() {
+function getCacheInfo() {
   return {
     hasWrite: !!writeInstance,
     hasRead: !!readInstance,
-    isReplica: !!(readInstance && readInstance !== writeInstance)
+    isReplica: !!(readInstance && readInstance !== writeInstance),
+    disabled: isDisabled
   };
 }
-var cacheLogger2, writeInstance, readInstance;
-var init_redis_manager = __esm({
-  "src/cache/redis-manager.ts"() {
-    init_redis_factory();
+var cacheLogger2, writeInstance, readInstance, isDisabled, getRedis, getRedisRead, setRedis, initRedis, closeRedis, getRedisInfo;
+var init_cache_manager = __esm({
+  "src/cache/cache-manager.ts"() {
+    init_cache_factory();
     init_logger2();
     cacheLogger2 = logger.child("cache");
+    isDisabled = false;
+    getRedis = getCache;
+    getRedisRead = getCacheRead;
+    setRedis = setCache;
+    initRedis = initCache;
+    closeRedis = closeCache;
+    getRedisInfo = getCacheInfo;
   }
 });
 
 // src/cache/index.ts
 var cache_exports = {};
 __export(cache_exports, {
+  closeCache: () => closeCache,
   closeRedis: () => closeRedis,
-  createRedisFromEnv: () => createRedisFromEnv,
-  createSingleRedisFromEnv: () => createSingleRedisFromEnv,
+  createCacheFromEnv: () => createCacheFromEnv,
+  createRedisFromEnv: () => createCacheFromEnv,
+  createSingleCacheFromEnv: () => createSingleCacheFromEnv,
+  createSingleRedisFromEnv: () => createSingleCacheFromEnv,
+  getCache: () => getCache,
+  getCacheInfo: () => getCacheInfo,
+  getCacheRead: () => getCacheRead,
   getRedis: () => getRedis,
   getRedisInfo: () => getRedisInfo,
   getRedisRead: () => getRedisRead,
+  initCache: () => initCache,
   initRedis: () => initRedis,
+  isCacheDisabled: () => isCacheDisabled,
+  setCache: () => setCache,
   setRedis: () => setRedis
 });
 var init_cache = __esm({
   "src/cache/index.ts"() {
-    init_redis_factory();
-    init_redis_manager();
+    init_cache_factory();
+    init_cache_manager();
+    init_cache_manager();
+    init_cache_factory();
   }
 });
 
@@ -2589,8 +2663,8 @@ var AutoRouteLoader = class {
     }
     let failureCount = 0;
     for (const file of files) {
-      const success = await this.loadRoute(app, file);
-      if (success) ; else {
+      const success2 = await this.loadRoute(app, file);
+      if (success2) ; else {
         failureCount++;
       }
     }
@@ -2606,14 +2680,15 @@ var AutoRouteLoader = class {
   }
   /**
    * Load routes from an external directory (e.g., from SPFN function packages)
-   * Routes use contract-based absolute paths, so no basePath prefix needed
+   * Reads package.json spfn.prefix and mounts routes under that prefix
    *
    * @param app - Hono app instance
    * @param routesDir - Directory containing route handlers
    * @param packageName - Name of the package (for logging)
+   * @param prefix - Optional prefix to mount routes under (from package.json spfn.prefix)
    * @returns Route statistics
    */
-  async loadExternalRoutes(app, routesDir, packageName) {
+  async loadExternalRoutes(app, routesDir, packageName, prefix) {
     const startTime = Date.now();
     const tempRoutesDir = this.routesDir;
     this.routesDir = routesDir;
@@ -2626,8 +2701,8 @@ var AutoRouteLoader = class {
     let successCount = 0;
     let failureCount = 0;
     for (const file of files) {
-      const success = await this.loadRoute(app, file);
-      if (success) {
+      const success2 = await this.loadRoute(app, file, prefix);
+      if (success2) {
         successCount++;
       } else {
         failureCount++;
@@ -2637,6 +2712,7 @@ var AutoRouteLoader = class {
     if (this.debug) {
       routeLogger2.info("External routes loaded", {
         package: packageName,
+        prefix: prefix || "/",
         total: successCount,
         failed: failureCount,
         elapsed: `${elapsed}ms`
@@ -2680,7 +2756,7 @@ var AutoRouteLoader = class {
   isValidRouteFile(fileName) {
     return fileName === "index.ts" || fileName === "index.js" || fileName === "index.mjs";
   }
-  async loadRoute(app, absolutePath) {
+  async loadRoute(app, absolutePath, prefix) {
     const relativePath = relative(this.routesDir, absolutePath);
     try {
       const module = await import(absolutePath);
@@ -2696,11 +2772,24 @@ var AutoRouteLoader = class {
         return false;
       }
       const contractPaths = this.extractContractPaths(module);
+      if (prefix) {
+        const invalidPaths = contractPaths.filter((path) => !path.startsWith(prefix));
+        if (invalidPaths.length > 0) {
+          routeLogger2.error("Contract paths must include the package prefix", {
+            file: relativePath,
+            prefix,
+            invalidPaths,
+            hint: `Contract paths should start with "${prefix}". Example: path: "${prefix}/labels"`
+          });
+          return false;
+        }
+      }
       this.registerContractBasedMiddlewares(app, contractPaths, module);
       app.route("/", module.default);
       contractPaths.forEach((path) => {
         this.routes.push({
           path,
+          // Use contract path as-is (already includes prefix)
           file: relativePath,
           meta: module.meta,
           priority: this.calculateContractPriority(path)
@@ -2711,8 +2800,8 @@ var AutoRouteLoader = class {
         }
       });
       return true;
-    } catch (error) {
-      this.categorizeAndLogError(error, relativePath);
+    } catch (error2) {
+      this.categorizeAndLogError(error2, relativePath);
       return false;
     }
   }
@@ -2768,9 +2857,9 @@ var AutoRouteLoader = class {
       }
     }
   }
-  categorizeAndLogError(error, relativePath) {
-    const message = error.message;
-    const stack = error.stack;
+  categorizeAndLogError(error2, relativePath) {
+    const message = error2.message;
+    const stack = error2.stack;
     if (message.includes("Cannot find module") || message.includes("MODULE_NOT_FOUND")) {
       routeLogger2.error("Missing dependency", {
         file: relativePath,
@@ -2827,15 +2916,16 @@ async function loadRoutes(app, options) {
       routeLogger2.info("Loading function routes", { count: functionRoutes.length });
       for (const func of functionRoutes) {
         try {
-          await loader.loadExternalRoutes(app, func.routesDir, func.packageName);
+          await loader.loadExternalRoutes(app, func.routesDir, func.packageName, func.prefix);
           routeLogger2.info("Function routes loaded", {
             package: func.packageName,
-            routesDir: func.routesDir
+            routesDir: func.routesDir,
+            prefix: func.prefix || "/"
           });
-        } catch (error) {
+        } catch (error2) {
           routeLogger2.error("Failed to load function routes", {
             package: func.packageName,
-            error: error instanceof Error ? error.message : "Unknown error"
+            error: error2 instanceof Error ? error2.message : "Unknown error"
           });
         }
       }
@@ -2870,6 +2960,7 @@ function ErrorHandler(options = {}) {
       });
     }
     const response = {
+      success: false,
       error: {
         message: err.message || "Internal Server Error",
         type: errorType,
@@ -2936,15 +3027,15 @@ function RequestLogger(config) {
         logData.slow = true;
       }
       apiLogger[logLevel]("Request completed", logData);
-    } catch (error) {
+    } catch (error2) {
       const duration = Date.now() - startTime;
-      apiLogger.error("Request failed", error, {
+      apiLogger.error("Request failed", error2, {
         requestId,
         method,
         path,
         duration
       });
-      throw error;
+      throw error2;
     }
   };
 }
@@ -2969,9 +3060,9 @@ function createHealthCheckHandler(detailed) {
         try {
           await db.execute("SELECT 1");
           dbStatus = "connected";
-        } catch (error) {
+        } catch (error2) {
           dbStatus = "error";
-          dbError = error instanceof Error ? error.message : String(error);
+          dbError = error2 instanceof Error ? error2.message : String(error2);
         }
       }
       const redis = getRedis2();
@@ -2981,9 +3072,9 @@ function createHealthCheckHandler(detailed) {
         try {
           await redis.ping();
           redisStatus = "connected";
-        } catch (error) {
+        } catch (error2) {
           redisStatus = "error";
-          redisError = error instanceof Error ? error.message : String(error);
+          redisError = error2 instanceof Error ? error2.message : String(error2);
         }
       }
       response.services = {
@@ -3131,8 +3222,8 @@ async function executeBeforeRoutesHook(app, config) {
   }
   try {
     await config.beforeRoutes(app);
-  } catch (error) {
-    serverLogger.error("beforeRoutes hook failed", error);
+  } catch (error2) {
+    serverLogger.error("beforeRoutes hook failed", error2);
     throw new Error("Server initialization failed in beforeRoutes hook");
   }
 }
@@ -3150,8 +3241,8 @@ async function executeAfterRoutesHook(app, config) {
   }
   try {
     await config.afterRoutes(app);
-  } catch (error) {
-    serverLogger.error("afterRoutes hook failed", error);
+  } catch (error2) {
+    serverLogger.error("afterRoutes hook failed", error2);
     throw new Error("Server initialization failed in afterRoutes hook");
   }
 }
@@ -3271,11 +3362,11 @@ async function startServer(config) {
         await shutdownServer();
       }
     };
-  } catch (error) {
-    const err = error;
+  } catch (error2) {
+    const err = error2;
     serverLogger2.error("Server initialization failed", err);
     await cleanupOnFailure();
-    throw error;
+    throw error2;
   }
 }
 async function loadAndMergeConfig(config) {
@@ -3373,8 +3464,8 @@ function createGracefulShutdown(shutdownServer, config) {
       ]);
       serverLogger2.info("Graceful shutdown completed successfully");
       process.exit(0);
-    } catch (error) {
-      const err = error;
+    } catch (error2) {
+      const err = error2;
       if (err.message && err.message.includes("timeout")) {
         serverLogger2.error("Graceful shutdown timeout, forcing exit", err);
       } else {
@@ -3387,8 +3478,8 @@ function createGracefulShutdown(shutdownServer, config) {
 function registerShutdownHandlers(shutdown) {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("uncaughtException", (error) => {
-    serverLogger2.error("Uncaught exception", error);
+  process.on("uncaughtException", (error2) => {
+    serverLogger2.error("Uncaught exception", error2);
     shutdown("UNCAUGHT_EXCEPTION");
   });
   process.on("unhandledRejection", (reason, promise) => {