effect-start 0.17.0 → 0.17.2

package/dist/Entity.js

@@ -0,0 +1,224 @@
+import * as Effect from "effect/Effect";
+import * as ParseResult from "effect/ParseResult";
+import * as Pipeable from "effect/Pipeable";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as StreamExtra from "./StreamExtra.js";
+import * as Values from "./Values.js";
+export const TypeId = Symbol.for("effect-start/Entity");
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+function isBinary(v) {
+    return v instanceof Uint8Array || v instanceof ArrayBuffer;
+}
+function parseJson(s) {
+    try {
+        return Effect.succeed(JSON.parse(s));
+    }
+    catch (e) {
+        return Effect.fail(new ParseResult.ParseError({
+            issue: new ParseResult.Type(Schema.Unknown.ast, s, e instanceof Error ? e.message : "Failed to parse JSON"),
+        }));
+    }
+}
+function getText(self) {
+    const v = self.body;
+    if (StreamExtra.isStream(v)) {
+        return Stream.mkString(Stream.decodeText(v));
+    }
+    if (Effect.isEffect(v)) {
+        return Effect.flatMap(v, (inner) => {
+            if (isEntity(inner)) {
+                return inner.text;
+            }
+            if (typeof inner === "string") {
+                return Effect.succeed(inner);
+            }
+            if (isBinary(inner)) {
+                return Effect.succeed(textDecoder.decode(inner));
+            }
+            return Effect.fail(mismatch(Schema.String, inner));
+        });
+    }
+    if (typeof v === "string") {
+        return Effect.succeed(v);
+    }
+    if (isBinary(v)) {
+        return Effect.succeed(textDecoder.decode(v));
+    }
+    return Effect.fail(mismatch(Schema.String, v));
+}
+function getJson(self) {
+    const v = self.body;
+    if (StreamExtra.isStream(v)) {
+        return Effect.flatMap(getText(self), parseJson);
+    }
+    if (Effect.isEffect(v)) {
+        return Effect.flatMap(v, (inner) => {
+            if (isEntity(inner)) {
+                return inner.json;
+            }
+            if (typeof inner === "object" && inner !== null && !isBinary(inner)) {
+                return Effect.succeed(inner);
+            }
+            if (typeof inner === "string") {
+                return parseJson(inner);
+            }
+            if (isBinary(inner)) {
+                return parseJson(textDecoder.decode(inner));
+            }
+            return Effect.fail(mismatch(Schema.Unknown, inner));
+        });
+    }
+    if (typeof v === "object" && v !== null && !isBinary(v)) {
+        return Effect.succeed(v);
+    }
+    if (typeof v === "string") {
+        return parseJson(v);
+    }
+    if (isBinary(v)) {
+        return parseJson(textDecoder.decode(v));
+    }
+    return Effect.fail(mismatch(Schema.Unknown, v));
+}
+function getBytes(self) {
+    const v = self.body;
+    if (StreamExtra.isStream(v)) {
+        return Stream.runFold(v, new Uint8Array(0), Values.concatBytes);
+    }
+    if (Effect.isEffect(v)) {
+        return Effect.flatMap(v, (inner) => {
+            if (isEntity(inner)) {
+                return inner.bytes;
+            }
+            if (inner instanceof Uint8Array) {
+                return Effect.succeed(inner);
+            }
+            if (inner instanceof ArrayBuffer) {
+                return Effect.succeed(new Uint8Array(inner));
+            }
+            if (typeof inner === "string") {
+                return Effect.succeed(textEncoder.encode(inner));
+            }
+            return Effect.fail(mismatch(Schema.Uint8ArrayFromSelf, inner));
+        });
+    }
+    if (v instanceof Uint8Array) {
+        return Effect.succeed(v);
+    }
+    if (v instanceof ArrayBuffer) {
+        return Effect.succeed(new Uint8Array(v));
+    }
+    if (typeof v === "string") {
+        return Effect.succeed(textEncoder.encode(v));
+    }
+    // Allows entity.stream to work when body is a JSON object
+    if (typeof v === "object" && v !== null && !isBinary(v)) {
+        return Effect.succeed(textEncoder.encode(JSON.stringify(v)));
+    }
+    return Effect.fail(mismatch(Schema.Uint8ArrayFromSelf, v));
+}
+function getStream(self) {
+    const v = self.body;
+    if (StreamExtra.isStream(v)) {
+        return v;
+    }
+    if (Effect.isEffect(v)) {
+        return Stream.unwrap(Effect.map(v, (inner) => {
+            if (isEntity(inner)) {
+                return inner.stream;
+            }
+            return Stream.fromEffect(getBytes(make(inner)));
+        }));
+    }
+    return Stream.fromEffect(getBytes(self));
+}
+const Proto = Object.defineProperties(Object.create(null), {
+    [TypeId]: { value: TypeId },
+    pipe: {
+        value: function () {
+            return Pipeable.pipeArguments(this, arguments);
+        },
+    },
+    text: {
+        get() {
+            return getText(this);
+        },
+    },
+    json: {
+        get() {
+            return getJson(this);
+        },
+    },
+    bytes: {
+        get() {
+            return getBytes(this);
+        },
+    },
+    stream: {
+        get() {
+            return getStream(this);
+        },
+    },
+});
+export function isEntity(input) {
+    return Predicate.hasProperty(input, TypeId);
+}
+export function make(body, options) {
+    return Object.assign(Object.create(Proto), {
+        body,
+        headers: options?.headers ?? {},
+        url: options?.url,
+        status: options?.status,
+    });
+}
+export function effect(body) {
+    return make(body);
+}
+export function resolve(entity) {
+    const body = entity.body;
+    if (Effect.isEffect(body)) {
+        return Effect.map(body, (inner) => isEntity(inner)
+            ? inner
+            : make(inner, {
+                status: entity.status,
+                headers: entity.headers,
+                url: entity.url,
+            }));
+    }
+    return Effect.succeed(entity);
+}
+export function type(self) {
+    const h = self.headers;
+    if (h["content-type"]) {
+        return h["content-type"];
+    }
+    const v = self.body;
+    if (typeof v === "string") {
+        return "text/plain";
+    }
+    if (typeof v === "object" && v !== null && !isBinary(v)) {
+        return "application/json";
+    }
+    return "application/octet-stream";
+}
+export function length(self) {
+    const h = self.headers;
+    if (h["content-length"]) {
+        return parseInt(h["content-length"], 10);
+    }
+    const v = self.body;
+    if (typeof v === "string") {
+        return textEncoder.encode(v).byteLength;
+    }
+    if (isBinary(v)) {
+        return v.byteLength;
+    }
+    return undefined;
+}
+function mismatch(expected, actual) {
+    return new ParseResult.ParseError({
+        issue: new ParseResult.Type(expected.ast, actual),
+    });
+}

package/dist/FileRouter.d.ts

@@ -0,0 +1,61 @@
+import type { PlatformError } from "@effect/platform/Error";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as FileRouterPattern from "./FileRouterPattern.ts";
+export type RouteModule = {
+    default: RouteSet.RouteSet.Default;
+};
+export type LazyRoute = {
+    path: `/${string}`;
+    load: () => Promise<RouteModule>;
+    layers?: ReadonlyArray<() => Promise<unknown>>;
+};
+type Manifest = {
+    routes: readonly LazyRoute[];
+};
+declare const FileRouter_base: Context.TagClass<FileRouter, "effect-start/FileRouter", Manifest>;
+export declare class FileRouter extends FileRouter_base {
+}
+export type GroupSegment<Name extends string = string> = FileRouterPattern.GroupSegment<Name>;
+export type Segment = FileRouterPattern.Segment;
+export type RouteHandle = {
+    handle: "route" | "layer";
+    modulePath: string;
+    routePath: `/${string}`;
+    segments: Segment[];
+};
+/**
+ * Routes are sorted by depth, layers are first,
+ * rest parameters are put at the end for each segment.
+ * - layer.tsx
+ * - users/route.tsx
+ * - users/[userId]/route.tsx
+ * - [[...rest]]/route.tsx
+ */
+export type OrderedRouteHandles = RouteHandle[];
+export declare const parse: typeof FileRouterPattern.parse;
+export declare const formatSegment: typeof FileRouterPattern.formatSegment;
+export declare const format: typeof FileRouterPattern.format;
+export declare function parseRoute(path: string): RouteHandle;
+/**
+ * Generates a manifest file that references all routes.
+ */
+export declare function layer(options: {
+    load: () => Promise<Manifest>;
+    path: string;
+}): Layer.Layer<FileRouter, PlatformError, FileSystem.FileSystem>;
+export declare function fromManifest(manifest: Manifest): Effect.Effect<Router.Router.Any>;
+export declare function walkRoutesDirectory(dir: string): Effect.Effect<OrderedRouteHandles, PlatformError, FileSystem.FileSystem>;
+/**
+ * Given a list of paths, return a list of route handles.
+ */
+export declare function getRouteHandlesFromPaths(paths: string[]): OrderedRouteHandles;
+type RouteTree = {
+    path: `/${string}`;
+    handles: RouteHandle[];
+    children?: RouteTree[];
+};
+export declare function treeFromRouteHandles(handles: RouteHandle[]): RouteTree;
+export {};

package/dist/FileRouter.js

@@ -0,0 +1,203 @@
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Array from "effect/Array";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+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 FileRouterCodegen from "./FileRouterCodegen.js";
+import * as FileRouterPattern from "./FileRouterPattern.js";
+export class FileRouter extends Context.Tag("effect-start/FileRouter")() {
+}
+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 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)`);
+    }
+    // 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`);
+            }
+        }
+    }
+    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 routePathSegments = pathSegments.filter(seg => seg._tag !== "GroupSegment");
+    const routePath = FileRouterPattern.format(routePathSegments);
+    return {
+        handle,
+        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);
+    }
+    if (NPath.extname(manifestPath) === "") {
+        manifestPath = NPath.join(manifestPath, "index.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);
+    })));
+}
+export function fromManifest(manifest) {
+    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);
+                }
+            }
+            mounts[lazyRoute.path] = mergedRouteSet;
+        }));
+        return Router.make(mounts, RouteSet.make());
+    });
+}
+export function walkRoutesDirectory(dir) {
+    return Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const files = yield* fs.readDirectory(dir, { recursive: true });
+        return getRouteHandlesFromPaths(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);
+        }
+        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 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

@@ -0,0 +1,19 @@
+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 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;
+/**
+ * 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;
+/**
+ * Updates the manifest 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>;

package/dist/FileRouterCodegen.js

@@ -0,0 +1,176 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+import * as NPath from "node:path";
+import * as FileRouter from "./FileRouter.js";
+import * as SchemaExtra from "./SchemaExtra.js";
+export function validateRouteModule(module) {
+    if (typeof module !== "object" || module === null) {
+        return false;
+    }
+    if (!("default" in module)) {
+        return false;
+    }
+    // TODO: verify we're exporting a proper shape
+    return true;
+}
+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 (Object.keys(fields).length === 0) {
+        return null;
+    }
+    return Schema.Struct(fields);
+}
+/**
+ * Validates all route modules in the given route handles.
+ */
+export function validateRouteModules(routesPath, handles) {
+    return Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const routeHandles = handles.filter(h => h.handle === "route");
+        for (const handle of routeHandles) {
+            const routeModulePath = NPath.resolve(routesPath, handle.modulePath);
+            const expectedSchema = generatePathParamsSchema(handle.segments);
+            const fileExists = yield* fs.exists(routeModulePath);
+            if (!fileExists) {
+                continue;
+            }
+            const module = yield* Effect.promise(() => import(__rewriteRelativeImportExtension(routeModulePath)));
+            if (!validateRouteModule(module)) {
+                yield* Effect.logWarning(`Route module ${routeModulePath} should export default Route`);
+                continue;
+            }
+            const routeSet = module.default;
+            // extract user schema
+            const userSchema = undefined;
+            if (expectedSchema
+                && userSchema
+                && !SchemaExtra.schemaEqual(userSchema, expectedSchema)) {
+                const relativeFilePath = NPath.relative(process.cwd(), routeModulePath);
+                yield* Effect.logError(`Route '${relativeFilePath}' has incorrect PathParams schema, expected schemaPathParams(${SchemaExtra.formatSchemaCode(expectedSchema)})`);
+            }
+        }
+    });
+}
+export function generateCode(handles) {
+    const routerModuleId = "effect-start";
+    // 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;
+        }
+        else if (handle.handle === "layer") {
+            existing.layers.push(handle);
+        }
+        routesByPath.set(handle.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 === "")
+            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
+    for (const [path, { route }] of routesByPath) {
+        if (!route)
+            continue; // Skip paths that only have layers
+        // Collect all parent layers that match the route's groups
+        const allLayers = [];
+        let currentPath = path;
+        while (true) {
+            const pathData = routesByPath.get(currentPath);
+            if (pathData?.layers) {
+                const matchingLayers = pathData.layers.filter(layer => layerMatchesRoute(layer, route));
+                allLayers.unshift(...matchingLayers);
+            }
+            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);
+    }
+    const header = `/**
+ * Auto-generated by effect-start.
+ */`;
+    const routesArray = routes.length > 0
+        ? `[\n${routes.join("\n")}\n]`
+        : "[]";
+    return `${header}
+
+export const routes = ${routesArray} as const
+`;
+}
+/**
+ * Updates the manifest 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") {
+    return Effect.gen(function* () {
+        manifestPath = NPath.resolve(routesPath, manifestPath);
+        const fs = yield* FileSystem.FileSystem;
+        const files = yield* fs.readDirectory(routesPath, { recursive: true });
+        const handles = FileRouter.getRouteHandlesFromPaths(files);
+        // Validate route modules
+        yield* validateRouteModules(routesPath, handles);
+        const newCode = generateCode(handles);
+        // Check if file exists and content differs
+        const existingCode = yield* fs
+            .readFileString(manifestPath)
+            .pipe(Effect.catchAll(() => Effect.succeed(null)));
+        if (existingCode !== newCode) {
+            yield* Effect.logDebug(`Updating file routes manifest: ${manifestPath}`);
+            yield* fs.writeFileString(manifestPath, newCode);
+        }
+        else {
+            yield* Effect.logDebug(`File routes manifest unchanged: ${manifestPath}`);
+        }
+    });
+}
+export function dump(routesPath, manifestPath = "manifest.ts") {
+    return Effect.gen(function* () {
+        manifestPath = NPath.resolve(routesPath, manifestPath);
+        const fs = yield* FileSystem.FileSystem;
+        const files = yield* fs.readDirectory(routesPath, { recursive: true });
+        const handles = FileRouter.getRouteHandlesFromPaths(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);
+    });
+}

package/dist/FileRouterPattern.d.ts

@@ -0,0 +1,9 @@
+import * as RouterPattern from "./RouterPattern.ts";
+export type GroupSegment<Name extends string = string> = {
+    _tag: "GroupSegment";
+    name: Name;
+};
+export type Segment = RouterPattern.Segment | GroupSegment;
+export declare function parse(pattern: string): Segment[];
+export declare function formatSegment(seg: Segment): string;
+export declare function format(segments: Segment[]): `/${string}`;