effect-start 0.19.0 → 0.20.1

package/dist/FileRouter.js

@@ -1,203 +1,149 @@
 import * as FileSystem from "@effect/platform/FileSystem";
-import * as Array from "effect/Array";
-import * as Context from "effect/Context";
+import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
+import * as Either from "effect/Either";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
-import * as Record from "effect/Record";
 import * as Stream from "effect/Stream";
 import * as NPath from "node:path";
 import * as NUrl from "node:url";
 import * as Development from "./Development.js";
+import * as FilePathPattern from "./FilePathPattern.js";
 import * as FileRouterCodegen from "./FileRouterCodegen.js";
-import * as FileRouterPattern from "./FileRouterPattern.js";
-export class FileRouter extends Context.Tag("effect-start/FileRouter")() {
+import * as NodeUtils from "./node/NodeUtils.js";
+import * as Route from "./Route.js";
+import * as RouteTree from "./RouteTree.js";
+export class FileRouterError extends Data.TaggedError("FileRouterError") {
 }
 const ROUTE_PATH_REGEX = /^\/?(.*\/?)(?:route|layer)\.(jsx?|tsx?)$/;
-export const parse = FileRouterPattern.parse;
-export const formatSegment = FileRouterPattern.formatSegment;
-export const format = FileRouterPattern.format;
 export function parseRoute(path) {
-    const segs = parse(path);
+    const segs = FilePathPattern.segments(path);
     const lastSeg = segs.at(-1);
     const handleMatch = lastSeg?._tag === "LiteralSegment"
         && lastSeg.value.match(/^(route|layer)\.(tsx?|jsx?)$/);
     const handle = handleMatch ? handleMatch[1] : null;
     if (!handle) {
-        throw new Error(`Invalid route path "${path}": must end with a valid handle (route or layer)`);
+        return null;
     }
-    // rest segments must be the last segment before the handle
-    const pathSegments = segs.slice(0, -1); // All segments except the handle
-    const restIndex = pathSegments.findIndex(seg => seg._tag === "RestSegment");
-    if (restIndex !== -1) {
-        // If there's a rest, it must be the last path segment
-        if (restIndex !== pathSegments.length - 1) {
-            throw new Error(`Invalid route path "${path}": rest segment ([...rest] or [[...rest]]) must be the last path segment before the handle`);
-        }
-        // all segments before the rest must be literal, param, or group
-        for (let i = 0; i < restIndex; i++) {
-            const seg = pathSegments[i];
-            if (seg._tag !== "LiteralSegment"
-                && seg._tag !== "ParamSegment"
-                && seg._tag !== "GroupSegment") {
-                throw new Error(`Invalid route path "${path}": segments before rest must be literal, param, or group segments`);
-            }
-        }
+    const pathSegments = segs.slice(0, -1);
+    const validated = FilePathPattern.validate(FilePathPattern.format(pathSegments));
+    if (Either.isLeft(validated)) {
+        return null;
     }
-    else {
-        // No rest: all path segments are literal, param, or group
-        for (const seg of pathSegments) {
-            if (seg._tag !== "LiteralSegment"
-                && seg._tag !== "ParamSegment"
-                && seg._tag !== "GroupSegment") {
-                throw new Error(`Invalid route path "${path}": path segments must be literal, param, or group segments`);
-            }
-        }
+    const restIndex = pathSegments.findIndex((seg) => seg._tag === "RestSegment");
+    if (restIndex !== -1 && restIndex !== pathSegments.length - 1) {
+        return null;
     }
-    const routePathSegments = pathSegments.filter(seg => seg._tag !== "GroupSegment");
-    const routePath = FileRouterPattern.format(routePathSegments);
+    const routePathSegments = pathSegments.filter((seg) => seg._tag !== "GroupSegment");
+    const routePath = FilePathPattern.format(routePathSegments);
     return {
         handle,
-        modulePath: path,
+        modulePath: `/${path}`,
         routePath,
         segments: pathSegments,
     };
 }
-/**
- * Generates a manifest file that references all routes.
- */
-export function layer(options) {
-    let manifestPath = options.path;
-    if (manifestPath.startsWith("file://")) {
-        manifestPath = NUrl.fileURLToPath(manifestPath);
+function importModule(load) {
+    return Effect.tryPromise({
+        try: () => load(),
+        catch: (cause) => new FileRouterError({ reason: "Import", cause }),
+    });
+}
+export function layer(loadOrOptions) {
+    const options = typeof loadOrOptions === "function"
+        ? {
+            load: loadOrOptions,
+            path: NPath.join(NodeUtils.getEntrypoint(), "routes"),
+        }
+        : loadOrOptions;
+    let treePath = options.path;
+    if (treePath.startsWith("file://")) {
+        treePath = NUrl.fileURLToPath(treePath);
     }
-    if (NPath.extname(manifestPath) === "") {
-        manifestPath = NPath.join(manifestPath, "index.ts");
+    if (NPath.extname(treePath) === "") {
+        treePath = NPath.join(treePath, "server.gen.ts");
     }
-    const routesPath = NPath.dirname(manifestPath);
-    const manifestFilename = NPath.basename(manifestPath);
-    const resolvedManifestPath = NPath.resolve(routesPath, manifestFilename);
-    return Layer.provide(Layer.effect(FileRouter, Effect.promise(() => options.load())), Layer.scopedDiscard(Effect.gen(function* () {
-        yield* FileRouterCodegen.update(routesPath, manifestFilename);
-        const stream = Function.pipe(Development.watchSource({
-            path: routesPath,
-            filter: (e) => !e.path.includes("node_modules"),
-        }), Stream.onError((e) => Effect.logError(e)));
-        yield* Function.pipe(stream, 
-        // filter out edits to gen file
-        Stream.filter(e => e.path !== resolvedManifestPath), Stream.runForEach(() => FileRouterCodegen.update(routesPath, manifestFilename)), Effect.fork);
-    })));
+    const routesPath = NPath.dirname(treePath);
+    const treeFilename = NPath.basename(treePath);
+    const relativeRoutesPath = NPath.relative(process.cwd(), routesPath);
+    return Layer.scoped(Route.Routes, Effect.gen(function* () {
+        // Generate routes file before loading
+        yield* FileRouterCodegen.update(routesPath, treeFilename);
+        // Load and build route tree
+        const m = yield* importModule(options.load);
+        const routeTree = yield* fromFileRoutes(m.default);
+        // Watch for changes (only when Development service is available)
+        yield* Function.pipe(Development.stream(), Stream.filter(e => e._tag !== "Reload" && e.path.startsWith(relativeRoutesPath)), Stream.runForEach(() => FileRouterCodegen.update(routesPath, treeFilename)), Effect.fork);
+        return routeTree;
+    }));
 }
-export function fromManifest(manifest) {
+export function fromFileRoutes(fileRoutes) {
     return Effect.gen(function* () {
         const mounts = {};
-        yield* Effect.forEach(manifest.routes, (lazyRoute) => Effect.gen(function* () {
-            const routeModule = yield* Effect.promise(() => lazyRoute.load());
-            const layerModules = lazyRoute.layers
-                ? yield* Effect.forEach(lazyRoute.layers, (loadLayer) => Effect.promise(() => loadLayer()))
-                : [];
-            // Start with the route from the route module
-            let mergedRouteSet = routeModule.default;
-            // Concatenate each layer's routes into the routeSet
-            for (const m of layerModules) {
-                const layerRouteSet = m.default;
-                if (RouteSet.isRouteSet(layerRouteSet)) {
-                    mergedRouteSet = Route.merge(layerRouteSet, mergedRouteSet);
+        for (const [path, loaders] of Object.entries(fileRoutes)) {
+            const modules = yield* Effect.forEach(loaders, (loader) => Effect.promise(() => loader()));
+            const allRoutes = [];
+            for (const m of modules) {
+                if (Route.isRouteSet(m.default)) {
+                    for (const route of m.default) {
+                        ;
+                        allRoutes.push(route);
+                    }
                 }
             }
-            mounts[lazyRoute.path] = mergedRouteSet;
-        }));
-        return Router.make(mounts, RouteSet.make());
+            mounts[path] = allRoutes;
+        }
+        return RouteTree.make(mounts);
     });
 }
 export function walkRoutesDirectory(dir) {
     return Effect.gen(function* () {
         const fs = yield* FileSystem.FileSystem;
         const files = yield* fs.readDirectory(dir, { recursive: true });
-        return getRouteHandlesFromPaths(files);
+        return yield* getFileRoutes(files);
     });
 }
-/**
- * Given a list of paths, return a list of route handles.
- */
-export function getRouteHandlesFromPaths(paths) {
-    const handles = paths
-        .map(f => f.match(ROUTE_PATH_REGEX))
-        .filter(Boolean)
-        .map(v => {
-        const path = v[0];
-        try {
-            return parseRoute(path);
+export function getFileRoutes(paths) {
+    return Effect.gen(function* () {
+        const routes = paths
+            .map(f => f.match(ROUTE_PATH_REGEX))
+            .filter(Boolean)
+            .map(v => {
+            const path = v[0];
+            try {
+                return parseRoute(path);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((route) => route !== null)
+            .toSorted((a, b) => {
+            const aDepth = a.segments.length;
+            const bDepth = b.segments.length;
+            const aHasRest = a.segments.some((seg) => seg._tag === "RestSegment");
+            const bHasRest = b.segments.some((seg) => seg._tag === "RestSegment");
+            return (
+            // rest is a dominant factor (routes with rest come last)
+            (+aHasRest - +bHasRest) * 1000
+                // depth is reversed for rest
+                + (aDepth - bDepth) * (1 - 2 * +aHasRest)
+                // lexicographic comparison as tiebreaker
+                + a.modulePath.localeCompare(b.modulePath) * 0.001);
+        });
+        // Detect conflicting routes at the same path
+        const routesByPath = new Map();
+        for (const route of routes) {
+            const existing = routesByPath.get(route.routePath) || [];
+            existing.push(route);
+            routesByPath.set(route.routePath, existing);
         }
-        catch {
-            return null;
+        for (const [path, pathRoutes] of routesByPath) {
+            const routeHandles = pathRoutes.filter(h => h.handle === "route");
+            if (routeHandles.length > 1) {
+                yield* new FileRouterError({ reason: "Conflict", path });
+            }
         }
-    })
-        .filter((route) => route !== null)
-        .toSorted((a, b) => {
-        const aDepth = a.segments.length;
-        const bDepth = b.segments.length;
-        const aHasRest = a.segments.some(seg => seg._tag === "RestSegment");
-        const bHasRest = b.segments.some(seg => seg._tag === "RestSegment");
-        return (
-        // rest is a dominant factor (routes with rest come last)
-        (+aHasRest - +bHasRest) * 1000
-            // depth is reversed for rest
-            + (aDepth - bDepth) * (1 - 2 * +aHasRest)
-            // lexicographic comparison as tiebreaker
-            + a.modulePath.localeCompare(b.modulePath) * 0.001);
+        return routes;
     });
-    // Detect conflicting routes at the same path
-    const routesByPath = new Map();
-    for (const handle of handles) {
-        const existing = routesByPath.get(handle.routePath) || [];
-        existing.push(handle);
-        routesByPath.set(handle.routePath, existing);
-    }
-    for (const [path, pathHandles] of routesByPath) {
-        const routeHandles = pathHandles.filter(h => h.handle === "route");
-        if (routeHandles.length > 1) {
-            const modulePaths = routeHandles.map(h => h.modulePath).join(", ");
-            throw new Error(`Conflicting routes detected at path ${path}: ${modulePaths}`);
-        }
-    }
-    return handles;
-}
-export function treeFromRouteHandles(handles) {
-    const handlesByPath = Array.groupBy(handles, handle => handle.routePath);
-    const paths = Record.keys(handlesByPath);
-    const root = {
-        path: "/",
-        handles: handlesByPath["/"] || [],
-    };
-    const nodeMap = new Map([["/", root]]);
-    for (const absolutePath of paths) {
-        if (absolutePath === "/")
-            continue;
-        // Find parent path
-        const segments = absolutePath.split("/").filter(Boolean);
-        const parentPath = segments.length === 1
-            ? "/"
-            : "/" + segments.slice(0, -1).join("/");
-        const parent = nodeMap.get(parentPath);
-        if (!parent) {
-            continue; // Skip orphaned paths
-        }
-        // Create node with relative path
-        const relativePath = parent.path === "/"
-            ? absolutePath
-            : absolutePath.slice(parentPath.length);
-        const node = {
-            path: relativePath,
-            handles: handlesByPath[absolutePath],
-        };
-        // Add to parent
-        if (!parent.children) {
-            parent.children = [];
-        }
-        parent.children.push(node);
-        // Store for future children
-        nodeMap.set(absolutePath, node);
-    }
-    return root;
 }

package/dist/FileRouterCodegen.d.ts

@@ -1,19 +1,18 @@
-import type { PlatformError } from "@effect/platform/Error";
 import * as FileSystem from "@effect/platform/FileSystem";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
+import * as FilePathPattern from "./FilePathPattern.ts";
 import * as FileRouter from "./FileRouter.ts";
-import * as FileRouterPattern from "./FileRouterPattern.ts";
 export declare function validateRouteModule(module: unknown): module is FileRouter.RouteModule;
-export declare function generatePathParamsSchema(segments: ReadonlyArray<FileRouterPattern.Segment>): Schema.Struct<any> | null;
+export declare function generatePathParamsSchema(segments: ReadonlyArray<FilePathPattern.Segment>): Schema.Struct<any> | null;
 /**
  * Validates all route modules in the given route handles.
  */
-export declare function validateRouteModules(routesPath: string, handles: FileRouter.OrderedRouteHandles): Effect.Effect<void, PlatformError, FileSystem.FileSystem>;
-export declare function generateCode(handles: FileRouter.OrderedRouteHandles): string;
+export declare function validateRouteModules(path: string, routes: FileRouter.OrderedFileRoutes): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem>;
+export declare function generateCode(fileRoutes: FileRouter.OrderedFileRoutes): string | null;
 /**
- * Updates the manifest file only if the generated content differs from the existing file.
+ * Updates the tree file only if the generated content differs from the existing file.
  * This prevents infinite loops when watching for file changes.
  */
-export declare function update(routesPath: string, manifestPath?: string): Effect.Effect<void, PlatformError, FileSystem.FileSystem>;
-export declare function dump(routesPath: string, manifestPath?: string): Effect.Effect<void, PlatformError, FileSystem.FileSystem>;
+export declare function update(routesPath: string, treePath?: string): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem>;
+export declare function dump(routesPath: string, treePath?: string): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem>;

package/dist/FileRouterCodegen.js

@@ -8,9 +8,10 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 };
 import * as FileSystem from "@effect/platform/FileSystem";
 import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
+import * as Either from "effect/Either";
 import * as Schema from "effect/Schema";
 import * as NPath from "node:path";
+import * as FilePathPattern from "./FilePathPattern.js";
 import * as FileRouter from "./FileRouter.js";
 import * as SchemaExtra from "./SchemaExtra.js";
 export function validateRouteModule(module) {
@@ -26,11 +27,11 @@ export function validateRouteModule(module) {
 export function generatePathParamsSchema(segments) {
     const fields = {};
     for (const segment of segments) {
-        if (segment._tag === "ParamSegment"
-            || segment._tag === "RestSegment") {
-            fields[segment.name] = segment.optional
-                ? Function.pipe(Schema.String, Schema.optional)
-                : Schema.String;
+        if (segment._tag === "ParamSegment") {
+            fields[segment.name] = Schema.String;
+        }
+        else if (segment._tag === "RestSegment") {
+            fields[segment.name] = Schema.optional(Schema.String);
         }
     }
     if (Object.keys(fields).length === 0) {
@@ -41,18 +42,25 @@ export function generatePathParamsSchema(segments) {
 /**
  * Validates all route modules in the given route handles.
  */
-export function validateRouteModules(routesPath, handles) {
+export function validateRouteModules(path, routes) {
     return Effect.gen(function* () {
         const fs = yield* FileSystem.FileSystem;
-        const routeHandles = handles.filter(h => h.handle === "route");
+        const routeHandles = routes.filter(h => h.handle === "route");
         for (const handle of routeHandles) {
-            const routeModulePath = NPath.resolve(routesPath, handle.modulePath);
+            const routeModulePath = NPath.resolve(path, handle.modulePath);
             const expectedSchema = generatePathParamsSchema(handle.segments);
-            const fileExists = yield* fs.exists(routeModulePath);
+            const fileExists = yield* fs.exists(routeModulePath).pipe(Effect.catchAll(() => Effect.succeed(false)));
             if (!fileExists) {
                 continue;
             }
-            const module = yield* Effect.promise(() => import(__rewriteRelativeImportExtension(routeModulePath)));
+            const module = yield* Effect.tryPromise({
+                try: () => import(__rewriteRelativeImportExtension(routeModulePath)),
+                catch: (cause) => new FileRouter.FileRouterError({
+                    reason: "Import",
+                    cause,
+                    path: routeModulePath,
+                }),
+            });
             if (!validateRouteModule(module)) {
                 yield* Effect.logWarning(`Route module ${routeModulePath} should export default Route`);
                 continue;
@@ -69,36 +77,31 @@ export function validateRouteModules(routesPath, handles) {
         }
     });
 }
-export function generateCode(handles) {
-    const routerModuleId = "effect-start";
+export function generateCode(fileRoutes) {
     // Group routes by path to find layers
     const routesByPath = new Map();
-    for (const handle of handles) {
-        const existing = routesByPath.get(handle.routePath) || { layers: [] };
-        if (handle.handle === "route") {
-            existing.route = handle;
+    for (const fileRoute of fileRoutes) {
+        const existing = routesByPath.get(fileRoute.routePath) || { layers: [] };
+        if (fileRoute.handle === "route") {
+            existing.route = fileRoute;
         }
-        else if (handle.handle === "layer") {
-            existing.layers.push(handle);
+        else if (fileRoute.handle === "layer") {
+            existing.layers.push(fileRoute);
         }
-        routesByPath.set(handle.routePath, existing);
+        routesByPath.set(fileRoute.routePath, existing);
     }
-    // Generate route definitions
-    const routes = [];
     // Helper to check if layer's path is an ancestor of route's path
     const layerMatchesRoute = (layer, route) => {
-        // Get the directory of the layer (strip the filename like layer.tsx)
-        const layerDir = layer.modulePath.replace(/\/?(layer)\.(tsx?|jsx?)$/, "");
-        // Layer at root (empty layerDir) applies to all routes
-        if (layerDir === "")
+        const layerDir = layer.modulePath.replace(/\/(layer)\.(tsx?|jsx?)$/, "");
+        if (layerDir === "/")
             return true;
-        // Route's modulePath must start with the layer's directory
         return route.modulePath.startsWith(layerDir + "/");
     };
-    // Find layers for each route by walking up the path hierarchy
+    // Build entries for each route path
+    const entries = [];
     for (const [path, { route }] of routesByPath) {
         if (!route)
-            continue; // Skip paths that only have layers
+            continue;
         // Collect all parent layers that match the route's groups
         const allLayers = [];
         let currentPath = path;
@@ -110,67 +113,95 @@ export function generateCode(handles) {
             }
             if (currentPath === "/")
                 break;
-            // Move to parent path
             const parentPath = currentPath.substring(0, currentPath.lastIndexOf("/"));
             currentPath = parentPath || "/";
         }
-        // Generate layers array
-        const layersCode = allLayers.length > 0
-            ? `\n    layers: [\n      ${allLayers.map(layer => `() => import("./${layer.modulePath}")`).join(",\n      ")},\n    ],`
-            : "";
-        const routeCode = `  {
-    path: "${path}",
-    load: () => import("./${route.modulePath}"),${layersCode}
-  },`;
-        routes.push(routeCode);
+        // Convert file-style path to colon-style PathPattern
+        const pathPatternResult = FilePathPattern.toPathPattern(path);
+        if (Either.isLeft(pathPatternResult)) {
+            continue;
+        }
+        const pathPattern = pathPatternResult.right;
+        // Order: route first, then layers from innermost to outermost
+        const loaders = [
+            `() => import(".${route.modulePath}")`,
+            ...allLayers.reverse().map(layer => `() => import(".${layer.modulePath}")`),
+        ];
+        entries.push({ path: pathPattern, loaders });
+    }
+    // No routes found - don't create file
+    if (entries.length === 0) {
+        return null;
     }
-    const header = `/**
+    const routeEntries = entries
+        .map(({ path, loaders }) => {
+        const loadersCode = loaders.join(",\n    ");
+        return `  "${path}": [\n    ${loadersCode},\n  ]`;
+    })
+        .join(",\n");
+    return `/**
  * Auto-generated by effect-start.
- */`;
-    const routesArray = routes.length > 0
-        ? `[\n${routes.join("\n")}\n]`
-        : "[]";
-    return `${header}
+ */
 
-export const routes = ${routesArray} as const
+export default {
+${routeEntries},
+} satisfies import("effect-start/FileRouter").FileRoutes
 `;
 }
 /**
- * Updates the manifest file only if the generated content differs from the existing file.
+ * Updates the tree file only if the generated content differs from the existing file.
  * This prevents infinite loops when watching for file changes.
  */
-export function update(routesPath, manifestPath = "manifest.ts") {
+export function update(routesPath, treePath = "server.gen.ts") {
     return Effect.gen(function* () {
-        manifestPath = NPath.resolve(routesPath, manifestPath);
+        treePath = NPath.resolve(routesPath, treePath);
         const fs = yield* FileSystem.FileSystem;
-        const files = yield* fs.readDirectory(routesPath, { recursive: true });
-        const handles = FileRouter.getRouteHandlesFromPaths(files);
+        const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: routesPath })));
+        const fileRoutes = yield* FileRouter.getFileRoutes(files);
         // Validate route modules
-        yield* validateRouteModules(routesPath, handles);
-        const newCode = generateCode(handles);
-        // Check if file exists and content differs
+        yield* validateRouteModules(routesPath, fileRoutes);
+        const newCode = generateCode(fileRoutes);
+        // Check if file exists (ok to fail - means file doesn't exist)
         const existingCode = yield* fs
-            .readFileString(manifestPath)
+            .readFileString(treePath)
             .pipe(Effect.catchAll(() => Effect.succeed(null)));
+        // No routes found
+        if (newCode === null) {
+            // If gen file exists, write empty export
+            if (existingCode !== null) {
+                const emptyCode = "export default {}\n";
+                if (existingCode !== emptyCode) {
+                    yield* Effect.logDebug(`Clearing file routes tree: ${treePath}`);
+                    yield* fs.writeFileString(treePath, emptyCode).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })));
+                }
+            }
+            return;
+        }
+        // Write if content differs
         if (existingCode !== newCode) {
-            yield* Effect.logDebug(`Updating file routes manifest: ${manifestPath}`);
-            yield* fs.writeFileString(manifestPath, newCode);
+            yield* Effect.logDebug(`Updating file routes tree: ${treePath}`);
+            yield* fs.writeFileString(treePath, newCode).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })));
         }
         else {
-            yield* Effect.logDebug(`File routes manifest unchanged: ${manifestPath}`);
+            yield* Effect.logDebug(`File routes tree unchanged: ${treePath}`);
         }
     });
 }
-export function dump(routesPath, manifestPath = "manifest.ts") {
+export function dump(routesPath, treePath = "server.gen.ts") {
     return Effect.gen(function* () {
-        manifestPath = NPath.resolve(routesPath, manifestPath);
+        treePath = NPath.resolve(routesPath, treePath);
         const fs = yield* FileSystem.FileSystem;
-        const files = yield* fs.readDirectory(routesPath, { recursive: true });
-        const handles = FileRouter.getRouteHandlesFromPaths(files);
+        const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: routesPath })));
+        const fileRoutes = yield* FileRouter.getFileRoutes(files);
         // Validate route modules
-        yield* validateRouteModules(routesPath, handles);
-        const code = generateCode(handles);
-        yield* Effect.logDebug(`Generating file routes manifest: ${manifestPath}`);
-        yield* fs.writeFileString(manifestPath, code);
+        yield* validateRouteModules(routesPath, fileRoutes);
+        const code = generateCode(fileRoutes);
+        // No routes found - don't create file
+        if (code === null) {
+            yield* Effect.logDebug(`No routes found, skipping: ${treePath}`);
+            return;
+        }
+        yield* Effect.logDebug(`Generating file routes tree: ${treePath}`);
+        yield* fs.writeFileString(treePath, code).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })));
     });
 }

package/dist/PlatformError.d.ts

@@ -0,0 +1,46 @@
+import type * as Cause from "effect/Cause";
+import * as Schema from "effect/Schema";
+import type * as Types from "effect/Types";
+import { TypeId as TypeId_ } from "@effect/platform/Error";
+export declare const TypeId: typeof TypeId_;
+export type TypeId = typeof TypeId;
+export declare const isPlatformError: (u: unknown) => u is PlatformError;
+export declare const TypeIdError: <const TypeId extends symbol, const Tag extends string>(typeId: TypeId, tag: Tag) => new <A extends Record<string, any>>(args: Types.Simplify<A>) => Cause.YieldableError & Record<TypeId, TypeId> & {
+    readonly _tag: Tag;
+} & Readonly<A>;
+export declare const Module: Schema.Literal<["Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal"]>;
+declare const BadArgument_base: Schema.TaggedErrorClass<BadArgument, "BadArgument", {
+    readonly _tag: Schema.tag<"BadArgument">;
+} & {
+    module: Schema.Literal<["Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal"]>;
+    method: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+export declare class BadArgument extends BadArgument_base {
+    readonly [TypeId]: typeof TypeId;
+    get message(): string;
+}
+export declare const SystemErrorReason: Schema.Literal<["AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero"]>;
+export type SystemErrorReason = typeof SystemErrorReason.Type;
+declare const SystemError_base: Schema.TaggedErrorClass<SystemError, "SystemError", {
+    readonly _tag: Schema.tag<"SystemError">;
+} & {
+    reason: Schema.Literal<["AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero"]>;
+    module: Schema.Literal<["Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal"]>;
+    method: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
+    syscall: Schema.optional<typeof Schema.String>;
+    pathOrDescriptor: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+export declare class SystemError extends SystemError_base {
+    readonly [TypeId]: typeof TypeId;
+    get message(): string;
+}
+export type PlatformError = BadArgument | SystemError;
+export declare const PlatformError: Schema.Union<[
+    typeof BadArgument,
+    typeof SystemError
+]>;
+export {};