@gigadrive/network-config 3.0.1 → 3.1.1

package/dist/index.mjs

@@ -1,6 +1,6 @@
 // src/detection/detect-framework.ts
-import { FileSystem as FileSystem3, Path as Path3 } from "@effect/platform";
-import { Effect as Effect4 } from "effect";
+import { FileSystem as FileSystem4, Path as Path3 } from "@effect/platform";
+import { Effect as Effect6 } from "effect";
 
 // src/detection/detect-package-manager.ts
 import { FileSystem, Path } from "@effect/platform";
@@ -157,21 +157,65 @@ var laravel = {
 };
 
 // src/detection/frameworks/nestjs.ts
-var nestjs = {
-  slug: "nestjs",
-  name: "NestJS",
-  language: "node",
-  detectors: [{ matchPackage: "@nestjs/core" }],
-  priority: 90,
-  getDefaultConfig: () => ({
+import { FileSystem as FileSystem2 } from "@effect/platform";
+import { Effect as Effect2 } from "effect";
+var isRecord = (value) => typeof value === "object" && value !== null;
+var parseNestCliJson = (content) => {
+  try {
+    const parsed = JSON.parse(content);
+    if (!isRecord(parsed)) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+};
+var getProjectOutputPath = (config) => {
+  if (typeof config.compilerOptions?.outputPath === "string") {
+    return config.compilerOptions.outputPath;
+  }
+  if (typeof config.defaultProject === "string") {
+    const outputPath2 = config.projects?.[config.defaultProject]?.compilerOptions?.outputPath;
+    if (typeof outputPath2 === "string") return outputPath2;
+  }
+  const firstProject = Object.values(config.projects ?? {})[0];
+  const outputPath = firstProject?.compilerOptions?.outputPath;
+  return typeof outputPath === "string" ? outputPath : void 0;
+};
+var normalizeOutputPath = (outputPath) => {
+  const normalized = outputPath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+  if (!normalized || normalized === "." || normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized) || normalized.includes(":") || normalized.split("/").some((segment) => segment === "..")) {
+    return void 0;
+  }
+  return normalized;
+};
+var createNestConfig = (outputPath) => {
+  const outputDirectory = normalizeOutputPath(outputPath) ?? "dist";
+  const entrypoint = `${outputDirectory}/main.js`;
+  return {
     runtime: "node-22",
     memory: 256,
     maxDuration: 30,
     streaming: true,
     commands: ["nest build"],
-    entrypoint: "dist/main.js",
-    routes: [{ source: "/*", destination: "dist/main.js" }],
+    entrypoint,
+    routes: [{ source: "/*", destination: entrypoint }],
     environmentVariables: { NODE_ENV: "production" }
+  };
+};
+var nestjs = {
+  slug: "nestjs",
+  name: "NestJS",
+  language: "node",
+  detectors: [{ matchPackage: "@nestjs/core" }],
+  priority: 90,
+  getDefaultConfig: () => createNestConfig("dist"),
+  refineDefaultConfig: (defaults, projectFolder) => Effect2.gen(function* () {
+    const fs = yield* FileSystem2.FileSystem;
+    const content = yield* fs.readFileString(`${projectFolder}/nest-cli.json`).pipe(Effect2.catchAll(() => Effect2.succeed(void 0)));
+    if (!content) return defaults;
+    const nestConfig = parseNestCliJson(content);
+    const outputPath = nestConfig ? getProjectOutputPath(nestConfig) : void 0;
+    return outputPath ? createNestConfig(outputPath) : defaults;
   })
 };
 
@@ -326,7 +370,7 @@ var FRAMEWORK_DEFINITIONS = [
 ].sort((a, b) => b.priority - a.priority);
 
 // src/detection/generate-config.ts
-import { Effect as Effect2 } from "effect";
+import { Effect as Effect3 } from "effect";
 
 // src/regions.ts
 var REGION_DEFINITIONS = [
@@ -366,11 +410,11 @@ var getInstallCommand = (pm) => {
       return "npm install";
   }
 };
-var generateConfig = Effect2.fn("generateConfig")(function* (framework, packageManager) {
-  const defaults = framework.getDefaultConfig(packageManager);
+var generateConfig = Effect3.fn("generateConfig")(function* (framework, packageManager, refinedDefaults) {
+  const defaults = refinedDefaults ?? framework.getDefaultConfig(packageManager);
   const installCmd = defaults.installCommand ?? getInstallCommand(packageManager);
   const commands = [installCmd, ...defaults.commands];
-  yield* Effect2.logDebug(`Generating config for ${framework.name}`, {
+  yield* Effect3.logDebug(`Generating config for ${framework.name}`, {
     runtime: defaults.runtime,
     entrypoint: defaults.entrypoint,
     commands
@@ -382,7 +426,8 @@ var generateConfig = Effect2.fn("generateConfig")(function* (framework, packageM
       memory: defaults.memory,
       maxDuration: defaults.maxDuration,
       streaming: defaults.streaming,
-      symlinks: defaults.symlinks
+      symlinks: defaults.symlinks,
+      package: defaults.package
     }
   ] : [];
   const routes = defaults.entrypoint ? defaults.routes.map((route) => ({
@@ -414,8 +459,8 @@ var generateConfig = Effect2.fn("generateConfig")(function* (framework, packageM
 });
 
 // src/detection/read-dependencies.ts
-import { FileSystem as FileSystem2, Path as Path2 } from "@effect/platform";
-import { Effect as Effect3 } from "effect";
+import { FileSystem as FileSystem3, Path as Path2 } from "@effect/platform";
+import { Effect as Effect5 } from "effect";
 
 // src/detection/types.ts
 import { Schema } from "effect";
@@ -448,25 +493,25 @@ var MANIFEST_CONFIG = {
   node: { file: "package.json", depKeys: ["dependencies", "devDependencies"] },
   php: { file: "composer.json", depKeys: ["require", "require-dev"] }
 };
-var readManifest = Effect3.fn("readManifest")(function* (filePath) {
-  const fs = yield* FileSystem2.FileSystem;
-  const exists = yield* fs.exists(filePath).pipe(Effect3.catchAll(() => Effect3.succeed(false)));
+var readManifest = Effect5.fn("readManifest")(function* (filePath) {
+  const fs = yield* FileSystem3.FileSystem;
+  const exists = yield* fs.exists(filePath).pipe(Effect5.catchAll(() => Effect5.succeed(false)));
   if (!exists) {
-    return yield* Effect3.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
+    return yield* Effect5.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
   }
-  const content = yield* fs.readFileString(filePath).pipe(Effect3.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
-  const parsed = yield* Effect3.try({
+  const content = yield* fs.readFileString(filePath).pipe(Effect5.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
+  const parsed = yield* Effect5.try({
     try: () => JSON.parse(content),
     catch: () => new ManifestParseError({ message: "Failed to parse manifest JSON", filePath })
   });
   return parsed;
 });
-var readDependencies = Effect3.fn("readDependencies")(function* (projectFolder, language) {
+var readDependencies = Effect5.fn("readDependencies")(function* (projectFolder, language) {
   const pathService = yield* Path2.Path;
   const config = MANIFEST_CONFIG[language];
   const filePath = pathService.join(projectFolder, config.file);
   const manifest = yield* readManifest(filePath).pipe(
-    Effect3.catchTag("ManifestNotFoundError", () => Effect3.succeed(null))
+    Effect5.catchTag("ManifestNotFoundError", () => Effect5.succeed(null))
   );
   if (!manifest) {
     return /* @__PURE__ */ new Set();
@@ -484,8 +529,8 @@ var readDependencies = Effect3.fn("readDependencies")(function* (projectFolder,
 });
 
 // src/detection/detect-framework.ts
-var matchesDetectionItem = Effect4.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
-  const fs = yield* FileSystem3.FileSystem;
+var matchesDetectionItem = Effect6.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
+  const fs = yield* FileSystem4.FileSystem;
   const pathService = yield* Path3.Path;
   if (item.matchPackage != null) {
     const deps = yield* cachedReadDeps(`${projectFolder}\0${framework.language}`);
@@ -495,12 +540,12 @@ var matchesDetectionItem = Effect4.fn("matchesDetectionItem")(function* (item, p
   }
   if (item.path != null) {
     const filePath = pathService.join(projectFolder, item.path);
-    const exists = yield* fs.exists(filePath).pipe(Effect4.catchAll(() => Effect4.succeed(false)));
+    const exists = yield* fs.exists(filePath).pipe(Effect6.catchAll(() => Effect6.succeed(false)));
     if (!exists) {
       return false;
     }
     if (item.matchContent != null) {
-      const content = yield* fs.readFileString(filePath).pipe(Effect4.catchAll(() => Effect4.succeed("")));
+      const content = yield* fs.readFileString(filePath).pipe(Effect6.catchAll(() => Effect6.succeed("")));
       let regexMatch = false;
       try {
         regexMatch = new RegExp(item.matchContent).test(content);
@@ -513,7 +558,7 @@ var matchesDetectionItem = Effect4.fn("matchesDetectionItem")(function* (item, p
   }
   return true;
 });
-var matchesFramework = Effect4.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
+var matchesFramework = Effect6.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
   for (const detector of framework.detectors) {
     const matches = yield* matchesDetectionItem(detector, projectFolder, framework, cachedReadDeps);
     if (!matches) {
@@ -522,9 +567,9 @@ var matchesFramework = Effect4.fn("matchesFramework")(function* (framework, proj
   }
   return true;
 });
-var detectFramework = Effect4.fn("detectFramework")(function* (projectFolder) {
-  yield* Effect4.logDebug(`Detecting framework in ${projectFolder}`);
-  const cachedReadDeps = yield* Effect4.cachedFunction((key) => {
+var detectFramework = Effect6.fn("detectFramework")(function* (projectFolder) {
+  yield* Effect6.logDebug(`Detecting framework in ${projectFolder}`);
+  const cachedReadDeps = yield* Effect6.cachedFunction((key) => {
     const sepIndex = key.lastIndexOf("\0");
     const folder = key.slice(0, sepIndex);
     const language = key.slice(sepIndex + 1);
@@ -533,13 +578,16 @@ var detectFramework = Effect4.fn("detectFramework")(function* (projectFolder) {
   for (const framework of FRAMEWORK_DEFINITIONS) {
     const matches = yield* matchesFramework(framework, projectFolder, cachedReadDeps);
     if (matches) {
-      yield* Effect4.log(`Detected framework: ${framework.name}`, { slug: framework.slug });
-      const packageManager = yield* detectPackageManager(projectFolder);
-      const config = yield* generateConfig(framework, packageManager);
+      yield* Effect6.log(`Detected framework: ${framework.name}`, { slug: framework.slug });
+      const detectedPackageManager = yield* detectPackageManager(projectFolder);
+      const packageManager = framework.language === "php" ? "composer" : detectedPackageManager;
+      const defaults = framework.getDefaultConfig(packageManager);
+      const refinedDefaults = framework.refineDefaultConfig ? yield* framework.refineDefaultConfig(defaults, projectFolder) : defaults;
+      const config = yield* generateConfig(framework, packageManager, refinedDefaults);
       return { framework, packageManager, config };
     }
   }
-  return yield* Effect4.fail(
+  return yield* Effect6.fail(
     new FrameworkNotDetectedError({
       message: `No framework detected in project directory`,
       directory: projectFolder
@@ -548,9 +596,9 @@ var detectFramework = Effect4.fn("detectFramework")(function* (projectFolder) {
 });
 
 // src/detection/merge-config.ts
-import { Effect as Effect5 } from "effect";
-var mergeWithFrameworkDefaults = Effect5.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
-  yield* Effect5.logDebug("Merging user config with framework defaults");
+import { Effect as Effect7 } from "effect";
+var mergeWithFrameworkDefaults = Effect7.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
+  yield* Effect7.logDebug("Merging user config with framework defaults");
   const merged = {
     regions: userConfig.regions,
     commands: userConfig.commands.length > 0 ? userConfig.commands : frameworkConfig.commands,
@@ -621,11 +669,11 @@ var filterFunctionsFromAssets = (config) => {
 };
 
 // src/parse-config.ts
-import { Effect as Effect11 } from "effect";
+import { Effect as Effect13 } from "effect";
 
 // src/services/raw-config-reader.ts
-import { FileSystem as FileSystem4, Path as Path4 } from "@effect/platform";
-import { Effect as Effect6 } from "effect";
+import { FileSystem as FileSystem5, Path as Path4 } from "@effect/platform";
+import { Effect as Effect8 } from "effect";
 import { parse as parseYaml } from "yaml";
 var ALLOWED_CONFIG_NAMES = [
   "gigadrive.yaml",
@@ -634,34 +682,34 @@ var ALLOWED_CONFIG_NAMES = [
   "nebula.yml",
   "nebula.json"
 ];
-var RawConfigReader = class extends Effect6.Service()("RawConfigReader", {
-  effect: Effect6.gen(function* () {
-    const fs = yield* FileSystem4.FileSystem;
+var RawConfigReader = class extends Effect8.Service()("RawConfigReader", {
+  effect: Effect8.gen(function* () {
+    const fs = yield* FileSystem5.FileSystem;
     const pathService = yield* Path4.Path;
-    const findConfig = Effect6.fn("RawConfigReader.findConfig")(function* (projectFolder) {
+    const findConfig = Effect8.fn("RawConfigReader.findConfig")(function* (projectFolder) {
       for (const name of ALLOWED_CONFIG_NAMES) {
         const filePath = pathService.join(projectFolder, name);
-        const exists = yield* fs.exists(filePath).pipe(Effect6.catchAll(() => Effect6.succeed(false)));
+        const exists = yield* fs.exists(filePath).pipe(Effect8.catchAll(() => Effect8.succeed(false)));
         if (exists) {
           return filePath;
         }
       }
       return null;
     });
-    const readRawConfig = Effect6.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
-      const exists = yield* fs.exists(filePath).pipe(Effect6.catchAll(() => Effect6.succeed(false)));
+    const readRawConfig = Effect8.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
+      const exists = yield* fs.exists(filePath).pipe(Effect8.catchAll(() => Effect8.succeed(false)));
       if (!exists) {
-        return yield* Effect6.fail(
+        return yield* Effect8.fail(
           new ConfigFileNotFoundError({ message: `Config file not found at ${filePath}`, filePath })
         );
       }
       const fileContents = yield* fs.readFileString(filePath).pipe(
-        Effect6.mapError(
+        Effect8.mapError(
           () => new ConfigFileParseError({ message: `Failed to read config file at ${filePath}`, filePath })
         )
       );
       if (fileContents.length === 0) {
-        return yield* Effect6.fail(
+        return yield* Effect8.fail(
           new ConfigFileEmptyError({ message: `Config file is empty at ${filePath}`, filePath })
         );
       }
@@ -676,7 +724,7 @@ var RawConfigReader = class extends Effect6.Service()("RawConfigReader", {
           parsed = parseYaml(fileContents);
         }
       } catch (error) {
-        return yield* Effect6.fail(
+        return yield* Effect8.fail(
           new ConfigFileParseError({
             message: `Failed to parse config file at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
             filePath,
@@ -685,21 +733,21 @@ var RawConfigReader = class extends Effect6.Service()("RawConfigReader", {
         );
       }
       if (parsed == null) {
-        return yield* Effect6.fail(
+        return yield* Effect8.fail(
           new ConfigFileParseError({ message: `Config file could not be parsed at ${filePath}`, filePath })
         );
       }
       if (!options?.disableVersionCheck && typeof parsed.version !== "number") {
-        return yield* Effect6.fail(
+        return yield* Effect8.fail(
           new ConfigVersionError({ message: `Config file is missing version at ${filePath}`, filePath })
         );
       }
       return parsed;
     });
     const readConfigFile = (configFilePath) => readRawConfig(configFilePath, { disableVersionCheck: true }).pipe(
-      Effect6.map((parsed) => parsed),
-      Effect6.catchTag("ConfigFileNotFoundError", () => Effect6.succeed(null)),
-      Effect6.withSpan("RawConfigReader.readConfigFile")
+      Effect8.map((parsed) => parsed),
+      Effect8.catchTag("ConfigFileNotFoundError", () => Effect8.succeed(null)),
+      Effect8.withSpan("RawConfigReader.readConfigFile")
     );
     return { findConfig, readRawConfig, readConfigFile };
   })
@@ -709,17 +757,17 @@ var RawConfigReader = class extends Effect6.Service()("RawConfigReader", {
 // src/services/schema-validator.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-import { Effect as Effect7 } from "effect";
-var SchemaValidator = class extends Effect7.Service()("SchemaValidator", {
-  effect: Effect7.gen(function* () {
+import { Effect as Effect9 } from "effect";
+var SchemaValidator = class extends Effect9.Service()("SchemaValidator", {
+  effect: Effect9.gen(function* () {
     const ajv = new Ajv();
     addFormats(ajv);
-    const validate = Effect7.fn("SchemaValidator.validate")(function* (config, schema, filePath) {
+    const validate = Effect9.fn("SchemaValidator.validate")(function* (config, schema, filePath) {
       const compiledValidate = ajv.compile(schema);
       const valid = compiledValidate(config);
       if (!valid) {
         const errors = compiledValidate.errors?.map((e) => `${e.instancePath || "/"} ${e.message ?? ""}`.trim()) ?? [];
-        return yield* Effect7.fail(
+        return yield* Effect9.fail(
           new ConfigSchemaValidationError({
             message: `Config file at ${filePath} is invalid: ${ajv.errorsText(compiledValidate.errors)}`,
             filePath,
@@ -734,9 +782,9 @@ var SchemaValidator = class extends Effect7.Service()("SchemaValidator", {
 };
 
 // src/services/v4-config-parser.ts
-import { FileSystem as FileSystem5, Path as Path5 } from "@effect/platform";
+import { FileSystem as FileSystem6, Path as Path5 } from "@effect/platform";
 import { getFilesForPattern } from "@gigadrive/build-utils";
-import { Effect as Effect8 } from "effect";
+import { Effect as Effect10 } from "effect";
 import { minimatch } from "minimatch";
 import safeRegex from "safe-regex2";
 var MAX_ASSET_DEPTH = 100;
@@ -749,6 +797,23 @@ var DEFAULT_FUNCTION_SETTINGS = {
   excludeFiles: void 0,
   includeFiles: void 0
 };
+var toArray = (value) => {
+  if (value == null) return void 0;
+  return Array.isArray(value) ? value : [value];
+};
+var runtimeStreamsByDefault = (runtime) => runtime == null || runtime.startsWith("node-") || runtime.startsWith("bun-");
+var normalizeRouteDestination = (destination) => {
+  const [withoutHash] = destination.split("#", 1);
+  const [withoutQuery] = withoutHash.split("?", 1);
+  return withoutQuery.replace(/^\/+/, "");
+};
+var destinationMatchesEntrypoint = (destination, entrypointPath) => {
+  const normalizedDestination = normalizeRouteDestination(destination);
+  if (normalizedDestination === entrypointPath) return true;
+  if (!normalizedDestination.includes("$")) return false;
+  const pattern = normalizedDestination.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\$[\w]+/g, ".+");
+  return new RegExp(`^${pattern}$`).test(entrypointPath);
+};
 var matchesPattern = (path2, pattern) => {
   if (minimatch(path2, pattern)) return true;
   try {
@@ -767,10 +832,12 @@ var getFunctionSettings = (path2, config) => {
   }
   return settings;
 };
-var resolveRouteHandler = (destination, redirect) => {
+var resolveRouteHandler = (destination, redirect, entrypoints = []) => {
   const isExternal = destination.toLowerCase().startsWith("http://") || destination.toLowerCase().startsWith("https://");
   if (redirect === true) return "HTTP_REDIRECT";
-  return isExternal ? "HTTP_PROXY" : "SERVERLESS_FUNCTION";
+  if (isExternal) return "HTTP_PROXY";
+  const matchingEntrypoints = entrypoints.filter((item) => destinationMatchesEntrypoint(destination, item.path));
+  return matchingEntrypoints.length > 0 && matchingEntrypoints.every((entrypoint) => entrypoint.streaming === true) ? "SERVERLESS_FUNCTION_STREAMING" : "SERVERLESS_FUNCTION";
 };
 var isRegion = (r) => AVAILABLE_REGIONS.includes(r);
 var resolveRegions = (configRegions) => {
@@ -778,28 +845,27 @@ var resolveRegions = (configRegions) => {
   const valid = configRegions?.filter(isRegion);
   return valid && valid.length > 0 ? valid : AVAILABLE_REGIONS;
 };
-var mapRoute = (route) => ({
+var mapRoute = (route, entrypoints) => ({
   path: route.source,
   destination: route.destination,
-  handler: resolveRouteHandler(route.destination, route.redirect),
+  handler: resolveRouteHandler(route.destination, route.redirect, entrypoints),
   headers: route.headers ?? {},
   methods: route.methods ?? ["ANY"],
   positiveRequirements: route.has,
   negativeRequirements: route.missing,
   status: route.statusCode
 });
-var parseEntrypoints = Effect8.fn("parseEntrypoints")(function* (config, projectFolder) {
+var parseEntrypoints = Effect10.fn("parseEntrypoints")(function* (config, projectFolder) {
   const entrypoints = [];
   if (config.functions == null) return entrypoints;
   for (const [fnPath, func] of Object.entries(config.functions)) {
-    const settings = getFunctionSettings(fnPath, config);
-    if (settings == null) {
-      yield* new FunctionConfigError({
+    if (getFunctionSettings(fnPath, config) == null) {
+      return yield* new FunctionConfigError({
         message: `Settings invalid for function at path '${fnPath}'`,
         functionPath: fnPath
       });
     }
-    const matchedFiles = yield* Effect8.tryPromise({
+    const matchedFiles = yield* Effect10.tryPromise({
       try: () => getFilesForPattern(fnPath, projectFolder, func.excludeFiles),
       catch: (error) => new FunctionConfigError({
         message: `Failed to resolve files for function pattern '${fnPath}': ${error instanceof Error ? error.message : String(error)}`,
@@ -809,27 +875,40 @@ var parseEntrypoints = Effect8.fn("parseEntrypoints")(function* (config, project
     for (const file of matchedFiles) {
       if (entrypoints.some((ep) => ep.path === file)) continue;
       if (Object.keys(config.functions).some((f) => f === file && f !== fnPath)) continue;
+      const settings = getFunctionSettings(file, config);
+      if (settings == null) {
+        return yield* new FunctionConfigError({
+          message: `Settings invalid for function at path '${file}'`,
+          functionPath: file
+        });
+      }
+      const runtime = settings.runtime ?? "node-20";
+      const streaming = settings.streaming ?? runtimeStreamsByDefault(runtime);
       entrypoints.push({
         path: file,
-        runtime: settings.runtime ?? "node-20",
+        runtime,
         memory: settings.memory ?? 128,
         maxDuration: settings.max_duration ?? 30,
         schedule: func.schedule,
         symlinks: func.symlinks,
-        streaming: settings.runtime == null || settings.runtime.startsWith("node-") || settings.runtime.startsWith("bun-")
+        streaming,
+        package: settings.includeFiles != null || settings.excludeFiles != null ? {
+          includeFiles: toArray(settings.includeFiles),
+          excludeFiles: toArray(settings.excludeFiles)
+        } : void 0
       });
     }
   }
   return entrypoints;
 });
-var collectAssets = Effect8.fn("collectAssets")(function* (config, projectFolder) {
+var collectAssets = Effect10.fn("collectAssets")(function* (config, projectFolder) {
   if (config.assets == null) return [];
-  const fs = yield* FileSystem5.FileSystem;
+  const fs = yield* FileSystem6.FileSystem;
   const pathService = yield* Path5.Path;
   const assetsPath = pathService.join(projectFolder, config.assets);
-  const assetsExist = yield* fs.exists(assetsPath).pipe(Effect8.catchAll(() => Effect8.succeed(false)));
+  const assetsExist = yield* fs.exists(assetsPath).pipe(Effect10.catchAll(() => Effect10.succeed(false)));
   if (!assetsExist) return [];
-  const stat = yield* fs.stat(assetsPath).pipe(Effect8.catchAll(() => Effect8.succeed(null)));
+  const stat = yield* fs.stat(assetsPath).pipe(Effect10.catchAll(() => Effect10.succeed(null)));
   if (!stat || stat.type !== "Directory") return [];
   const allFiles = yield* collectFilesRecursively(assetsPath);
   const assets = [];
@@ -840,18 +919,18 @@ var collectAssets = Effect8.fn("collectAssets")(function* (config, projectFolder
   }
   return assets;
 });
-var collectFilesRecursively = Effect8.fn("collectFilesRecursively")(
+var collectFilesRecursively = Effect10.fn("collectFilesRecursively")(
   function* (basePath, relativePath = "", depth = 0) {
     if (depth > MAX_ASSET_DEPTH) return [];
-    const fs = yield* FileSystem5.FileSystem;
+    const fs = yield* FileSystem6.FileSystem;
     const pathSvc = yield* Path5.Path;
     const currentPath = relativePath ? pathSvc.join(basePath, relativePath) : basePath;
-    const entries = yield* fs.readDirectory(currentPath).pipe(Effect8.catchAll(() => Effect8.succeed([])));
+    const entries = yield* fs.readDirectory(currentPath).pipe(Effect10.catchAll(() => Effect10.succeed([])));
     const result = [];
     for (const name of entries) {
       const fullPath = pathSvc.join(currentPath, name);
       const entryRelative = relativePath ? pathSvc.join(relativePath, name) : name;
-      const stat = yield* fs.stat(fullPath).pipe(Effect8.catchAll(() => Effect8.succeed(null)));
+      const stat = yield* fs.stat(fullPath).pipe(Effect10.catchAll(() => Effect10.succeed(null)));
       if (!stat) continue;
       if (stat.type === "Directory") {
         const nested = yield* collectFilesRecursively(basePath, entryRelative, depth + 1);
@@ -863,16 +942,16 @@ var collectFilesRecursively = Effect8.fn("collectFilesRecursively")(
     return result;
   }
 );
-var V4ConfigParser = class extends Effect8.Service()("V4ConfigParser", {
+var V4ConfigParser = class extends Effect10.Service()("V4ConfigParser", {
   accessors: true,
-  effect: Effect8.succeed({
+  effect: Effect10.succeed({
     /**
      * Parses a ConfigV4 into a NormalizedConfig.
      *
      * @param config - The raw V4 config object
      * @param projectFolder - Absolute path to the project root
      */
-    parse: Effect8.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
+    parse: Effect10.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
       const entrypoints = yield* parseEntrypoints(config, projectFolder);
       const assets = yield* collectAssets(config, projectFolder);
       return {
@@ -888,7 +967,7 @@ var V4ConfigParser = class extends Effect8.Service()("V4ConfigParser", {
         entrypoints,
         errors: [],
         warnings: [],
-        routes: (config.routes ?? []).map(mapRoute)
+        routes: (config.routes ?? []).map((route) => mapRoute(route, entrypoints))
       };
     })
   })
@@ -899,7 +978,7 @@ var V4ConfigParser = class extends Effect8.Service()("V4ConfigParser", {
 import { Path as Path7 } from "@effect/platform";
 import { getFilesForPattern as getFilesForPattern2 } from "@gigadrive/build-utils";
 import { deepMerge } from "@gigadrive/commons";
-import { Effect as Effect10 } from "effect";
+import { Effect as Effect12 } from "effect";
 
 // src/build-output-v3/determine-repo-root.ts
 import path from "path";
@@ -935,24 +1014,24 @@ var determineRepoRoot = (projectFolder, config) => {
 };
 
 // src/build-output-v3/get-default-path-map.ts
-import { FileSystem as FileSystem6, Path as Path6 } from "@effect/platform";
-import { Effect as Effect9 } from "effect";
-var getDefaultPathMap = Effect9.fn("getDefaultPathMap")(function* (directory) {
-  const fs = yield* FileSystem6.FileSystem;
+import { FileSystem as FileSystem7, Path as Path6 } from "@effect/platform";
+import { Effect as Effect11 } from "effect";
+var getDefaultPathMap = Effect11.fn("getDefaultPathMap")(function* (directory) {
+  const fs = yield* FileSystem7.FileSystem;
   const pathService = yield* Path6.Path;
   const result = {};
-  const exists = yield* fs.exists(directory).pipe(Effect9.catchAll(() => Effect9.succeed(false)));
+  const exists = yield* fs.exists(directory).pipe(Effect11.catchAll(() => Effect11.succeed(false)));
   if (!exists) {
     return result;
   }
   const MAX_DEPTH = 100;
-  const processDirectory = (currentPath, basePath = "", depth = 0) => Effect9.gen(function* () {
+  const processDirectory = (currentPath, basePath = "", depth = 0) => Effect11.gen(function* () {
     if (depth > MAX_DEPTH) return;
-    const entries = yield* fs.readDirectory(currentPath).pipe(Effect9.catchAll(() => Effect9.succeed([])));
+    const entries = yield* fs.readDirectory(currentPath).pipe(Effect11.catchAll(() => Effect11.succeed([])));
     for (const name of entries) {
       const fullPath = pathService.join(currentPath, name);
       const relativePath = basePath ? pathService.join(basePath, name) : name;
-      const stat = yield* fs.stat(fullPath).pipe(Effect9.catchAll(() => Effect9.succeed(null)));
+      const stat = yield* fs.stat(fullPath).pipe(Effect11.catchAll(() => Effect11.succeed(null)));
       if (!stat) continue;
       if (stat.type === "Directory") {
         yield* processDirectory(fullPath, relativePath, depth + 1);
@@ -1026,11 +1105,11 @@ var translateVercelRuntime = (runtime) => {
 var CONFIG_PATH = ".vercel/output/config.json";
 var FUNCTIONS_FOLDER = ".vercel/output/functions";
 var FUNCTION_CONFIGS_PATTERN = `${FUNCTIONS_FOLDER}/**/*.func/.vc-config.json`;
-var VercelBuildOutputParser = class extends Effect10.Service()("VercelBuildOutputParser", {
-  effect: Effect10.gen(function* () {
+var VercelBuildOutputParser = class extends Effect12.Service()("VercelBuildOutputParser", {
+  effect: Effect12.gen(function* () {
     const rawConfigReader = yield* RawConfigReader;
     const pathService = yield* Path7.Path;
-    const parse = Effect10.fn("VercelBuildOutputParser.parse")(function* (parseResult, projectFolder) {
+    const parse = Effect12.fn("VercelBuildOutputParser.parse")(function* (parseResult, projectFolder) {
       const config = yield* rawConfigReader.readConfigFile(pathService.join(projectFolder, CONFIG_PATH));
       if (!config || typeof config.version !== "number" || config.version < 3) {
         return parseResult;
@@ -1041,8 +1120,8 @@ var VercelBuildOutputParser = class extends Effect10.Service()("VercelBuildOutpu
       merged.regions = [...new Set(merged.regions)];
       return merged;
     });
-    const loadFunctions = Effect10.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
-      const functionConfigs = yield* Effect10.tryPromise({
+    const loadFunctions = Effect12.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
+      const functionConfigs = yield* Effect12.tryPromise({
         try: () => getFilesForPattern2(FUNCTION_CONFIGS_PATTERN, projectFolder),
         catch: (error) => new ConfigFileParseError({
           message: `Failed to scan for function configs: ${error instanceof Error ? error.message : String(error)}`,
@@ -1088,7 +1167,7 @@ var VercelBuildOutputParser = class extends Effect10.Service()("VercelBuildOutpu
             Object.assign(environmentVariables, env);
           }
         }
-        const streaming = runtime.startsWith("node-") || runtime.startsWith("bun-");
+        const streaming = functionConfig.supportsResponseStreaming ?? functionConfig.experimentalResponseStreaming ?? runtime.startsWith("node-");
         let filePathMap = {};
         for (const [key, value] of Object.entries(configFilePathMap)) {
           filePathMap[pathService.join(projectFolder, key)] = value;
@@ -1224,6 +1303,10 @@ var schema_default = {
             $ref: "#/$defs/runtimes",
             description: "The runtime to use for the function."
           },
+          streaming: {
+            type: "boolean",
+            description: "Enable function response streaming. When omitted, Node and Bun runtimes stream by default."
+          },
           schedule: {
             type: "string",
             description: "An expression to schedule the function to run at specific times.",
@@ -1496,7 +1579,7 @@ var schema_default = {
 };
 
 // src/parse-config.ts
-var parseConfigRaw = Effect11.fn("parseConfigRaw")(function* (filePath, projectFolder) {
+var parseConfigRaw = Effect13.fn("parseConfigRaw")(function* (filePath, projectFolder) {
   const rawReader = yield* RawConfigReader;
   const validator = yield* SchemaValidator;
   const v4Parser = yield* V4ConfigParser;
@@ -1507,7 +1590,7 @@ var parseConfigRaw = Effect11.fn("parseConfigRaw")(function* (filePath, projectF
   };
   const schema = schemaMap[version];
   if (!schema) {
-    return yield* Effect11.fail(
+    return yield* Effect13.fail(
       new ConfigVersionError({
         message: `Config file at ${filePath} has an unsupported version: ${version}`,
         filePath,
@@ -1518,11 +1601,11 @@ var parseConfigRaw = Effect11.fn("parseConfigRaw")(function* (filePath, projectF
   yield* validator.validate(parsed, schema, filePath);
   return yield* v4Parser.parse(parsed, projectFolder);
 });
-var parseConfig = Effect11.fn("parseConfig")(function* (filePath, projectFolder) {
+var parseConfig = Effect13.fn("parseConfig")(function* (filePath, projectFolder) {
   const parseResult = yield* parseConfigRaw(filePath, projectFolder);
   return yield* postProcessConfig(parseResult, projectFolder);
 });
-var postProcessConfig = Effect11.fn("postProcessConfig")(function* (config, projectFolder) {
+var postProcessConfig = Effect13.fn("postProcessConfig")(function* (config, projectFolder) {
   const vercelParser = yield* VercelBuildOutputParser;
   let result = yield* vercelParser.parse(config, projectFolder);
   if (result.entrypoints.length === 0 && (result.assets?.paths?.length || 0) === 0 && result.routes.length === 0) {