@typed/app 1.0.0-beta.1

package/dist/internal/emitHttpApiSource.js

@@ -0,0 +1,404 @@
+/**
+ * Emits static HttpApi assembly from endpoint modules.
+ * Endpoint exports: route (path + pathSchema + querySchema), method, handler;
+ * optional headers, body, error, success. Handler receives { path, query, headers, body }
+ * with type-safe decoding. Use HttpApiSchema.status(code) on error/success schemas
+ * to annotate response status codes.
+ *
+ * TypeInfo-first: only emits references to exports that are in optionalExportsByPath.
+ * The compiler must know what is available from TypeInfo—if it's not there, it is not emitted.
+ */
+import { basename, dirname, join, relative } from "node:path";
+import { compareHttpApiPathOrder } from "./httpapiFileRoles.js";
+import { stripScriptExtension, toPosixPath } from "./path.js";
+import { makeUniqueVarNames, pathToIdentifier } from "./routeIdentifiers.js";
+const ROOT_GROUP_KEY = "__root__";
+const DIRECTORY_CONVENTION_KINDS = [
+    "_dependencies.ts",
+    "_middlewares.ts",
+    "_prefix.ts",
+    "_openapi.ts",
+];
+function createMutableDirectoryCompanionPaths() {
+    return {
+        "_dependencies.ts": [],
+        "_middlewares.ts": [],
+        "_prefix.ts": [],
+        "_openapi.ts": [],
+    };
+}
+function freezeDirectoryCompanionPaths(paths) {
+    return {
+        "_dependencies.ts": [...paths["_dependencies.ts"]],
+        "_middlewares.ts": [...paths["_middlewares.ts"]],
+        "_prefix.ts": [...paths["_prefix.ts"]],
+        "_openapi.ts": [...paths["_openapi.ts"]],
+    };
+}
+function createDirectoryConventionIndexEntry() {
+    return {
+        apiRootPaths: [],
+        groupOverridePaths: [],
+        companionPaths: createMutableDirectoryCompanionPaths(),
+    };
+}
+function normalizeDirPath(dirPath) {
+    return dirPath === "." ? "" : dirPath;
+}
+function dirnamePosix(path) {
+    const index = path.lastIndexOf("/");
+    return index < 0 ? "" : path.slice(0, index);
+}
+function ancestorDirs(dirPath) {
+    const normalized = normalizeDirPath(dirPath);
+    if (normalized === "")
+        return [""];
+    const segments = normalized.split("/").filter(Boolean);
+    const out = [""];
+    let current = "";
+    for (const segment of segments) {
+        current = current ? `${current}/${segment}` : segment;
+        out.push(current);
+    }
+    return out;
+}
+function pushUnique(values, value) {
+    if (!values.includes(value))
+        values.push(value);
+}
+function pushUniqueMany(values, incoming) {
+    for (const value of incoming) {
+        pushUnique(values, value);
+    }
+}
+function sortDirectoryCompanionPaths(paths) {
+    for (const kind of DIRECTORY_CONVENTION_KINDS) {
+        paths[kind].sort(compareHttpApiPathOrder);
+    }
+}
+function upsertIndexEntry(index, dirPath) {
+    const normalized = normalizeDirPath(dirPath);
+    const existing = index.get(normalized);
+    if (existing)
+        return existing;
+    const created = createDirectoryConventionIndexEntry();
+    index.set(normalized, created);
+    return created;
+}
+function addConventionToIndex(entry, convention) {
+    if (convention.kind === "api_root") {
+        pushUnique(entry.apiRootPaths, convention.path);
+        return;
+    }
+    if (convention.kind === "group_override") {
+        pushUnique(entry.groupOverridePaths, convention.path);
+        return;
+    }
+    pushUnique(entry.companionPaths[convention.kind], convention.path);
+}
+function indexDirectoryConventions(tree) {
+    const index = new Map();
+    const rootEntry = upsertIndexEntry(index, "");
+    for (const convention of tree.conventions) {
+        addConventionToIndex(rootEntry, convention);
+    }
+    const visit = (nodes) => {
+        for (const node of nodes) {
+            if (node.type === "endpoint")
+                continue;
+            const entry = upsertIndexEntry(index, node.dirPath);
+            for (const convention of node.conventions) {
+                addConventionToIndex(entry, convention);
+            }
+            visit(node.children);
+        }
+    };
+    visit(tree.children);
+    for (const entry of index.values()) {
+        entry.apiRootPaths.sort(compareHttpApiPathOrder);
+        entry.groupOverridePaths.sort(compareHttpApiPathOrder);
+        sortDirectoryCompanionPaths(entry.companionPaths);
+    }
+    return index;
+}
+function collectEndpointNodesWithGroupKey(nodes, currentGroupKey) {
+    const out = [];
+    for (const node of nodes) {
+        if (node.type === "endpoint") {
+            out.push({ node, groupKey: currentGroupKey });
+            continue;
+        }
+        if (node.type === "group") {
+            out.push(...collectEndpointNodesWithGroupKey(node.children, node.dirPath));
+            continue;
+        }
+        out.push(...collectEndpointNodesWithGroupKey(node.children, currentGroupKey));
+    }
+    return out;
+}
+function collectGroupNodes(nodes) {
+    const out = [];
+    for (const node of nodes) {
+        if (node.type === "group") {
+            out.push(node);
+            out.push(...collectGroupNodes(node.children));
+            continue;
+        }
+        if (node.type === "pathless_directory") {
+            out.push(...collectGroupNodes(node.children));
+        }
+    }
+    return out;
+}
+function mapEndpointCompanionPaths(node) {
+    const mapped = {};
+    for (const companion of node.companions) {
+        if (!mapped[companion.kind]) {
+            mapped[companion.kind] = companion.path;
+        }
+    }
+    return {
+        ".name": mapped[".name"],
+        ".dependencies": mapped[".dependencies"],
+        ".middlewares": mapped[".middlewares"],
+        ".prefix": mapped[".prefix"],
+        ".openapi": mapped[".openapi"],
+    };
+}
+function createDirectoryCompanionPathsForDir(dirPath, index) {
+    const merged = createMutableDirectoryCompanionPaths();
+    for (const ancestor of ancestorDirs(dirPath)) {
+        const entry = index.get(ancestor);
+        if (!entry)
+            continue;
+        for (const kind of DIRECTORY_CONVENTION_KINDS) {
+            pushUniqueMany(merged[kind], entry.companionPaths[kind]);
+        }
+    }
+    sortDirectoryCompanionPaths(merged);
+    return freezeDirectoryCompanionPaths(merged);
+}
+function buildEndpointRenderSpecs(tree, index) {
+    const endpointEntries = collectEndpointNodesWithGroupKey(tree.children, ROOT_GROUP_KEY);
+    const specs = [];
+    for (const entry of endpointEntries) {
+        const endpointDir = dirnamePosix(entry.node.path);
+        specs.push({
+            path: entry.node.path,
+            stem: entry.node.stem,
+            groupKey: entry.groupKey,
+            modulePath: entry.node.path,
+            companions: mapEndpointCompanionPaths(entry.node),
+            directoryCompanions: createDirectoryCompanionPathsForDir(endpointDir, index),
+        });
+    }
+    return specs.sort((a, b) => compareHttpApiPathOrder(a.path, b.path));
+}
+function compareGroupKeys(a, b) {
+    const left = a === ROOT_GROUP_KEY ? "" : a;
+    const right = b === ROOT_GROUP_KEY ? "" : b;
+    return compareHttpApiPathOrder(left, right);
+}
+function buildGroupRenderSpecs(tree, index, endpoints) {
+    const byDir = new Map();
+    for (const groupNode of collectGroupNodes(tree.children)) {
+        byDir.set(groupNode.dirPath, groupNode);
+    }
+    const groupKeys = new Set(byDir.keys());
+    if (endpoints.some((endpoint) => endpoint.groupKey === ROOT_GROUP_KEY)) {
+        groupKeys.add(ROOT_GROUP_KEY);
+    }
+    const specs = [];
+    const sortedKeys = [...groupKeys].sort(compareGroupKeys);
+    for (const groupKey of sortedKeys) {
+        const dirPath = groupKey === ROOT_GROUP_KEY ? "" : groupKey;
+        const node = byDir.get(groupKey);
+        const defaultName = node?.groupName ?? "root";
+        const entry = index.get(dirPath);
+        specs.push({
+            key: groupKey,
+            dirPath,
+            defaultName,
+            overridePath: entry?.groupOverridePaths[0],
+            directoryCompanions: createDirectoryCompanionPathsForDir(dirPath, index),
+        });
+    }
+    return specs;
+}
+function buildApiRenderSpec(targetDirectory, index) {
+    const rootEntry = index.get("");
+    return {
+        defaultIdentifier: basename(targetDirectory) || "api",
+        apiRootPath: rootEntry?.apiRootPaths[0],
+        directoryCompanions: freezeDirectoryCompanionPaths(rootEntry ? rootEntry.companionPaths : createMutableDirectoryCompanionPaths()),
+    };
+}
+function toImportSpecifier(importerDir, targetDir, relativeFilePath) {
+    const absPath = join(targetDir, relativeFilePath);
+    const rel = toPosixPath(relative(importerDir, absPath));
+    const specifier = rel.startsWith(".") ? rel : `./${rel}`;
+    return stripScriptExtension(specifier) + ".js";
+}
+const METHOD_FACTORIES = {
+    GET: "get",
+    POST: "post",
+    PUT: "put",
+    PATCH: "patch",
+    DELETE: "delete",
+    HEAD: "head",
+    OPTIONS: "options",
+};
+const OPTIONAL_ENDPOINT_EXPORTS = ["headers", "body", "success", "error"];
+/** body maps to payload in HttpApiEndpoint options */
+const EXPORT_TO_OPTION = {
+    headers: "headers",
+    body: "payload",
+    success: "success",
+    error: "error",
+};
+export function emitHttpApiSource(input) {
+    const directoryConventions = indexDirectoryConventions(input.tree);
+    const endpointSpecs = buildEndpointRenderSpecs(input.tree, directoryConventions);
+    const groupSpecs = buildGroupRenderSpecs(input.tree, directoryConventions, endpointSpecs);
+    const apiSpec = buildApiRenderSpec(input.targetDirectory, directoryConventions);
+    const endpointPaths = endpointSpecs.map((e) => e.modulePath);
+    const importerDir = dirname(toPosixPath(input.importer));
+    const proposedNames = endpointPaths.map((path) => ({
+        path,
+        proposedName: pathToIdentifier(path),
+    }));
+    const varNameByPath = makeUniqueVarNames(proposedNames);
+    const importLines = [
+        `import { emptyRecordString, emptyRecordStringArray, composeWithLayers, resolveConfig, type AppConfig, type ComputeLayers, type LayerOrGroup, type RunConfig } from "@typed/app";`,
+        `import * as Effect from "effect/Effect";`,
+        `import * as Layer from "effect/Layer";`,
+        `import * as HttpApi from "effect/unstable/httpapi/HttpApi";`,
+        `import * as HttpApiBuilder from "effect/unstable/httpapi/HttpApiBuilder";`,
+        `import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";`,
+        `import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";`,
+        `import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";`,
+        `import * as HttpApiScalar from "effect/unstable/httpapi/HttpApiScalar";`,
+        `import * as HttpApiSwagger from "effect/unstable/httpapi/HttpApiSwagger";`,
+        `import * as HttpServer from "effect/unstable/http/HttpServer";`,
+        `import * as HttpRouter from "effect/unstable/http/HttpRouter";`,
+        `import * as OpenApiModule from "effect/unstable/httpapi/OpenApi";`,
+        `import http from "node:http";`,
+        `import { NodeHttpServer } from "@effect/platform-node";`,
+    ];
+    for (const path of endpointPaths) {
+        const importSpecifier = toImportSpecifier(importerDir, input.targetDirectory, path);
+        importLines.push(`import * as ${varNameByPath.get(path)} from ${JSON.stringify(importSpecifier)};`);
+    }
+    const apiId = apiSpec.defaultIdentifier;
+    const groupExprs = [];
+    for (const groupSpec of groupSpecs) {
+        const endpointsInGroup = endpointSpecs.filter((e) => e.groupKey === groupSpec.key);
+        if (endpointsInGroup.length === 0)
+            continue;
+        const endpointExprs = [];
+        for (const ep of endpointsInGroup) {
+            const varName = varNameByPath.get(ep.modulePath);
+            const literals = input.extractedLiteralsByPath.get(ep.path);
+            const method = (literals?.method ?? "GET").toUpperCase();
+            const name = literals?.name ?? ep.stem;
+            const factory = METHOD_FACTORIES[method] ?? "get";
+            const m = varName;
+            const optionalPresent = input.optionalExportsByPath.get(ep.path) ?? new Set();
+            const optsParts = [
+                `params: ${m}.route.pathSchema`,
+                `query: ${m}.route.querySchema`,
+            ];
+            for (const exp of OPTIONAL_ENDPOINT_EXPORTS) {
+                if (optionalPresent.has(exp)) {
+                    const optName = EXPORT_TO_OPTION[exp];
+                    optsParts.push(`${optName}: ${m}.${exp}`);
+                }
+            }
+            const opts = optsParts.join(", ");
+            endpointExprs.push(`HttpApiEndpoint.${factory}(${JSON.stringify(name)}, ${m}.route.path, { ${opts} })`);
+        }
+        const groupName = groupSpec.defaultName;
+        const groupChain = endpointExprs.map((expr) => `.add(${expr})`).join("");
+        groupExprs.push(`HttpApiGroup.make(${JSON.stringify(groupName)})${groupChain}`);
+    }
+    const apiChain = groupExprs.map((g) => `.add(${g})`).join("");
+    const apiExpr = `HttpApi.make(${JSON.stringify(apiId)})${apiChain}`;
+    const groupLayerBlocks = [];
+    for (const groupSpec of groupSpecs) {
+        const endpointsInGroup = endpointSpecs.filter((e) => e.groupKey === groupSpec.key);
+        if (endpointsInGroup.length === 0)
+            continue;
+        const groupName = groupSpec.defaultName;
+        const handlerIsRaw = input.handlerIsRawByPath;
+        const handleCalls = endpointsInGroup
+            .map((e) => {
+            const varName = varNameByPath.get(e.modulePath);
+            const literals = input.extractedLiteralsByPath.get(e.path);
+            const name = literals?.name ?? e.stem;
+            const isRaw = handlerIsRaw?.get(e.path) === true;
+            if (isRaw) {
+                return `.handleRaw(${JSON.stringify(name)}, (ctx) => ${varName}.handler(ctx))`;
+            }
+            const optPresent = input.optionalExportsByPath.get(e.path) ?? new Set();
+            const headersArg = optPresent.has("headers") ? "ctx.headers" : "emptyRecordString";
+            const bodyArg = optPresent.has("body") ? "ctx.payload" : "undefined";
+            return `.handle(${JSON.stringify(name)}, (ctx) => ${varName}.handler({ path: ctx.params ?? emptyRecordString, query: ctx.query ?? emptyRecordStringArray, headers: ${headersArg}, body: ${bodyArg} }))`;
+        })
+            .join("\n      ");
+        groupLayerBlocks.push(`HttpApiBuilder.group(Api, ${JSON.stringify(groupName)}, (handlers) => handlers${handleCalls})`);
+    }
+    const baseApiLayer = `HttpApiBuilder.layer(Api)`;
+    const mergedApiLayer = groupLayerBlocks.length === 0
+        ? baseApiLayer
+        : groupLayerBlocks.reduce((acc, groupBlock) => `${acc}.pipe(Layer.provideMerge(${groupBlock}))`, baseApiLayer);
+    const middlewaresPath = apiSpec.directoryCompanions["_middlewares.ts"][0];
+    const hasMiddlewares = Boolean(middlewaresPath);
+    if (hasMiddlewares) {
+        const middlewareSpecifier = toImportSpecifier(importerDir, input.targetDirectory, middlewaresPath);
+        importLines.push(`import * as ApiMiddlewares from ${JSON.stringify(middlewareSpecifier)};`);
+    }
+    const serveOptions = hasMiddlewares
+        ? `{ disableListenLog, middleware: ApiMiddlewares.middleware ?? ApiMiddlewares.default }`
+        : `{ disableListenLog }`;
+    return `${importLines.join("\n")}
+
+export const Api = ${apiExpr};
+export const ApiLayer = ${mergedApiLayer};
+export const OpenApi = OpenApiModule.fromApi(Api);
+export const Swagger = HttpApiSwagger.layer(Api);
+export const Scalar = HttpApiScalar.layer(Api);
+export const Client = HttpApiClient.make(Api);
+
+export const App = <const Layers extends readonly LayerOrGroup[] = []>(
+  config?: AppConfig,
+  ...layersToMergeIntoRouter: Layers
+): Layer.Layer<
+  Layer.Success<ComputeLayers<Layers, typeof ApiLayer>>, 
+  Layer.Error<ComputeLayers<Layers, typeof ApiLayer>>, 
+  Exclude<Layer.Services<ComputeLayers<Layers, typeof ApiLayer>>, HttpRouter.HttpRouter> | HttpServer.HttpServer
+> => {
+  const disableListenLog = config?.disableListenLog ?? false;
+  const appLayer = composeWithLayers(ApiLayer, layersToMergeIntoRouter) as ComputeLayers<
+    Layers,
+    typeof ApiLayer
+  >;
+  return HttpRouter.serve(appLayer, ${serveOptions})
+};
+
+export const serve = <const Layers extends readonly LayerOrGroup[] = []>(
+  config?: RunConfig,
+  ...layersToMergeIntoRouter: Layers
+) =>
+  Layer.unwrap(
+    Effect.gen(function* () {
+      const host = yield* resolveConfig(config?.host, "0.0.0.0");
+      const port = yield* resolveConfig(config?.port, 3000);
+      const disableListenLog = yield* resolveConfig(config?.disableListenLog, false);
+      const appConfig: AppConfig = { disableListenLog };
+      const appLayer = App(appConfig, ...layersToMergeIntoRouter);
+      const serverLayer = NodeHttpServer.layer(http.createServer, { host, port });
+      return appLayer.pipe(Layer.provide(serverLayer));
+    }),
+  );
+`;
+}

package/dist/internal/emitRouterHelpers.d.ts

@@ -0,0 +1,17 @@
+import type { CatchForm, DepsExportKind, RuntimeKind } from "./routeTypeNode.js";
+/**
+ * Emit the handler expression that converts to a function returning Fx.
+ * Router passes RefSubject<Params> (an Fx) to function handlers.
+ * Plain sync handlers (value in, value out) always use Fx.map(params, handler).
+ */
+export declare function handlerExprFor(runtimeKind: RuntimeKind, isFn: boolean, expectsRefSubject: boolean, varName: string, exportName: string): string;
+/** Lift a value or function result to Fx based on return kind (plain, effect, stream, fx). */
+export declare function liftToFx(expr: string, kind: RuntimeKind): string;
+/**
+ * Emit the catch expression that converts to (causeRef) => Fx form.
+ * Supports: value fallbacks, (Cause) => ..., (E) => ..., and native (causeRef) => Fx.
+ */
+export declare function catchExprFor(catchForm: CatchForm, varName: string, exportName: string): string;
+/** Targeted lift for .provide() based on dependency export kind (layer, servicemap, array). */
+export declare function depsExprFor(kind: DepsExportKind, varName: string): string;
+//# sourceMappingURL=emitRouterHelpers.d.ts.map

package/dist/internal/emitRouterHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitRouterHelpers.d.ts","sourceRoot":"","sources":["../../src/internal/emitRouterHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjF;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,OAAO,EACb,iBAAiB,EAAE,OAAO,EAC1B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,MAAM,CAoBR;AAED,8FAA8F;AAC9F,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,CAahE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAoB9F;AAED,+FAA+F;AAC/F,wBAAgB,WAAW,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAUzE"}

package/dist/internal/emitRouterHelpers.js

@@ -0,0 +1,74 @@
+/**
+ * Emit the handler expression that converts to a function returning Fx.
+ * Router passes RefSubject<Params> (an Fx) to function handlers.
+ * Plain sync handlers (value in, value out) always use Fx.map(params, handler).
+ */
+export function handlerExprFor(runtimeKind, isFn, expectsRefSubject, varName, exportName) {
+    const ref = `${varName}.${exportName}`;
+    if (runtimeKind === "plain") {
+        return isFn ? `(params) => Fx.map(params, ${ref})` : `constant(Fx.succeed(${ref}))`;
+    }
+    if (isFn && expectsRefSubject) {
+        return `(params) => ${ref}(params)`;
+    }
+    switch (runtimeKind) {
+        case "effect":
+            return isFn ? `(params) => Fx.mapEffect(params, ${ref})` : `constant(Fx.fromEffect(${ref}))`;
+        case "stream":
+            return isFn
+                ? `(params) => Fx.switchMap(params, (p) => Fx.fromStream(${ref}(p)))`
+                : `constant(Fx.fromStream(${ref}))`;
+        case "fx":
+            return isFn ? ref : `constant(${ref})`;
+        case "unknown":
+            throw new Error("RVM-KIND-001: runtime kind unknown (should have been caught in buildRouteDescriptors)");
+    }
+}
+/** Lift a value or function result to Fx based on return kind (plain, effect, stream, fx). */
+export function liftToFx(expr, kind) {
+    switch (kind) {
+        case "plain":
+            return `Fx.succeed(${expr})`;
+        case "effect":
+            return `Fx.fromEffect(${expr})`;
+        case "stream":
+            return `Fx.fromStream(${expr})`;
+        case "fx":
+            return expr;
+        case "unknown":
+            throw new Error("RVM-KIND-001: runtime kind unknown (should have been caught in buildRouteDescriptors)");
+    }
+}
+/**
+ * Emit the catch expression that converts to (causeRef) => Fx form.
+ * Supports: value fallbacks, (Cause) => ..., (E) => ..., and native (causeRef) => Fx.
+ */
+export function catchExprFor(catchForm, varName, exportName) {
+    const ref = `${varName}.${exportName}`;
+    const { form, returnKind } = catchForm;
+    if (form === "native") {
+        return ref;
+    }
+    if (form === "value") {
+        const lifted = liftToFx(ref, returnKind);
+        return `(_causeRef) => ${lifted}`;
+    }
+    if (form === "fn-cause") {
+        const lifted = liftToFx(`${ref}(cause)`, returnKind);
+        return `(causeRef) => Fx.flatMap(causeRef, (cause) => ${lifted})`;
+    }
+    // form === "fn-error": (e) => A | Effect | Stream | Fx — use Cause.findFail + Result.match
+    return `(causeRef) => Fx.flatMap(causeRef, (cause) => Result.match(Cause.findFail(cause), { onFailure: (c) => Fx.fromEffect(Effect.failCause(c)), onSuccess: ({ error: e }) => ${liftToFx(`${ref}(e)`, returnKind)} }))`;
+}
+/** Targeted lift for .provide() based on dependency export kind (layer, servicemap, array). */
+export function depsExprFor(kind, varName) {
+    const ref = `${varName}.default`;
+    switch (kind) {
+        case "layer":
+            return ref;
+        case "servicemap":
+            return `Layer.succeedServices(${ref})`;
+        case "array":
+            return `Router.normalizeDependencyInput(${ref})`;
+    }
+}

package/dist/internal/emitRouterSource.d.ts

@@ -0,0 +1,8 @@
+import type { CatchFormByPath, CatchExportByPath, DepsFormByPath, GuardExportByPath, RouteDescriptor } from "./buildRouteDescriptors.js";
+/**
+ * Emit Router.merge(...) of directory matchers. Each route compiles to .match(route, { handler, ...opts })
+ * with opts only from in-file or sibling. Directory companions (_layout, _dependencies, _catch) apply to
+ * all routes in that directory and are added once per directory via .layout(), .provide(), .catchCause().
+ */
+export declare function emitRouterMatchSource(descriptors: readonly RouteDescriptor[], targetDirectory: string, importer: string, guardExportByPath: GuardExportByPath, catchExportByPath: CatchExportByPath, catchFormByPath: CatchFormByPath, depsFormByPath: DepsFormByPath): string;
+//# sourceMappingURL=emitRouterSource.d.ts.map

package/dist/internal/emitRouterSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitRouterSource.d.ts","sourceRoot":"","sources":["../../src/internal/emitRouterSource.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAqEpC;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,SAAS,eAAe,EAAE,EACvC,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,iBAAiB,EACpC,iBAAiB,EAAE,iBAAiB,EACpC,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,cAAc,GAC7B,MAAM,CAgGR"}

package/dist/internal/emitRouterSource.js

@@ -0,0 +1,139 @@
+import { basename, dirname, join, relative } from "node:path";
+import { buildRouterDescriptorTree, renderRouterDescriptorTree, } from "./routerDescriptorTree.js";
+import { siblingCompanionPath } from "./buildRouteDescriptors.js";
+import { catchExprFor, depsExprFor, handlerExprFor } from "./emitRouterHelpers.js";
+import { makeUniqueVarNames, pathToIdentifier, routeModuleIdentifier } from "./routeIdentifiers.js";
+import { stripScriptExtension, toPosixPath } from "./path.js";
+/** Path relative to baseDir → import specifier relative to importerDir (script ext → .js for ESM). */
+function toImportSpecifier(importerDir, targetDir, relativeFilePath) {
+    const absPath = join(targetDir, relativeFilePath);
+    const rel = toPosixPath(relative(importerDir, absPath));
+    const specifier = rel.startsWith(".") ? rel : `./${rel}`;
+    return stripScriptExtension(specifier) + ".js";
+}
+/** Canonical root directory: Node's dirname returns "." for root-level files; we use "" consistently. */
+function normalizeDir(dir) {
+    return dir === "." ? "" : dir;
+}
+/** True iff the companion path is directory-level (e.g. api/_layout.ts), not sibling (e.g. route.layout.ts). */
+function isDirectoryCompanion(p) {
+    return basename(p).startsWith("_");
+}
+/** Directory path -> companion paths for that directory (only _layout, _dependencies, _catch; guard is per-route). */
+function directoryCompanionPaths(descriptors) {
+    const map = new Map();
+    for (const d of descriptors) {
+        for (const kind of ["layout", "dependencies", "catch"]) {
+            for (const p of d.composedConcerns[kind]) {
+                if (!isDirectoryCompanion(p))
+                    continue;
+                const dir = normalizeDir(dirname(p));
+                let entry = map.get(dir);
+                if (!entry) {
+                    entry = {};
+                    map.set(dir, entry);
+                }
+                if (!entry[kind])
+                    entry[kind] = p;
+            }
+        }
+    }
+    return map;
+}
+/** Collect unique paths in leaf→ancestor order (closest to route first; first occurrence wins). */
+function collectOrderedCompanionPaths(descriptors, kind) {
+    const seen = new Set();
+    const out = [];
+    for (const d of descriptors) {
+        const paths = d.composedConcerns[kind];
+        for (const p of paths) {
+            if (!seen.has(p)) {
+                seen.add(p);
+                out.push(p);
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Emit Router.merge(...) of directory matchers. Each route compiles to .match(route, { handler, ...opts })
+ * with opts only from in-file or sibling. Directory companions (_layout, _dependencies, _catch) apply to
+ * all routes in that directory and are added once per directory via .layout(), .provide(), .catchCause().
+ */
+export function emitRouterMatchSource(descriptors, targetDirectory, importer, guardExportByPath, catchExportByPath, catchFormByPath, depsFormByPath) {
+    const importerDir = dirname(toPosixPath(importer));
+    const needsFnErrorImports = Object.values(catchFormByPath).some((f) => f.form === "fn-error");
+    const needsLayerImport = Object.values(depsFormByPath).includes("servicemap");
+    const depPaths = collectOrderedCompanionPaths(descriptors, "dependencies");
+    const layoutPaths = collectOrderedCompanionPaths(descriptors, "layout");
+    const guardPaths = collectOrderedCompanionPaths(descriptors, "guard");
+    const catchPaths = collectOrderedCompanionPaths(descriptors, "catch");
+    const nameEntries = [
+        ...descriptors.map((d) => ({
+            path: d.filePath,
+            proposedName: routeModuleIdentifier(d.filePath),
+        })),
+        ...depPaths.map((p) => ({ path: p, proposedName: pathToIdentifier(p) })),
+        ...layoutPaths.map((p) => ({ path: p, proposedName: pathToIdentifier(p) })),
+        ...guardPaths.map((p) => ({ path: p, proposedName: pathToIdentifier(p) })),
+        ...catchPaths.map((p) => ({ path: p, proposedName: pathToIdentifier(p) })),
+    ];
+    const varNameByPath = makeUniqueVarNames(nameEntries);
+    const importLines = [
+        `import * as Router from "@typed/router";`,
+        `import * as Fx from "@typed/fx/Fx";`,
+        `import { constant } from "effect/Function";`,
+        ...(needsFnErrorImports
+            ? [
+                `import * as Effect from "effect/Effect";`,
+                `import * as Cause from "effect/Cause";`,
+                `import * as Result from "effect/Result";`,
+            ]
+            : []),
+        ...(needsLayerImport ? [`import * as Layer from "effect/Layer";`] : []),
+    ];
+    for (const d of descriptors) {
+        const spec = toImportSpecifier(importerDir, targetDirectory, d.filePath);
+        const varName = varNameByPath.get(d.filePath);
+        importLines.push(`import * as ${varName} from ${JSON.stringify(spec)};`);
+    }
+    for (const p of depPaths) {
+        importLines.push(`import * as ${varNameByPath.get(p)} from ${JSON.stringify(toImportSpecifier(importerDir, targetDirectory, p))};`);
+    }
+    for (const p of layoutPaths) {
+        importLines.push(`import * as ${varNameByPath.get(p)} from ${JSON.stringify(toImportSpecifier(importerDir, targetDirectory, p))};`);
+    }
+    for (const p of guardPaths) {
+        importLines.push(`import * as ${varNameByPath.get(p)} from ${JSON.stringify(toImportSpecifier(importerDir, targetDirectory, p))};`);
+    }
+    for (const p of catchPaths) {
+        importLines.push(`import * as ${varNameByPath.get(p)} from ${JSON.stringify(toImportSpecifier(importerDir, targetDirectory, p))};`);
+    }
+    const dirToCompanions = directoryCompanionPaths(descriptors);
+    const descriptorTree = buildRouterDescriptorTree({
+        descriptors,
+        dirToCompanions,
+        guardExportByPath,
+        catchExportByPath,
+        catchFormByPath,
+        normalizeDir,
+        isDirectoryCompanion,
+        siblingCompanionPath,
+    });
+    const handlerExprForMatch = (match, varName) => handlerExprFor(match.runtimeKind, match.entrypointIsFunction, match.entrypointExpectsRefSubject, varName, match.entrypointExport);
+    const rootSource = renderRouterDescriptorTree(descriptorTree, {
+        varNameByPath,
+        guardExportByPath,
+        catchExportByPath,
+        catchFormByPath,
+        depsFormByPath,
+        handlerExprFor: handlerExprForMatch,
+        catchExprFor,
+        depsExprFor,
+    });
+    return `${importLines.join("\n")}
+
+const router = ${rootSource};
+export default router;
+`;
+}

package/dist/internal/extractHttpApiLiterals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Extract path and method from endpoint TypeInfo snapshot.
+ * Uses TypeInfoApi export types instead of parsing source with TypeScript.
+ * Handles literal, object, and reference (e.g. Route<P,S>) shapes; unknown kinds return null.
+ */
+import type { TypeInfoFileSnapshot } from "@typed/virtual-modules";
+export interface ExtractedEndpointLiterals {
+    readonly path: string;
+    readonly method: string;
+    readonly name: string;
+}
+/**
+ * Extracts route path and method from TypeInfo snapshot exports.
+ * Reads from route and method exports; path from route type (literal or object.path).
+ */
+export declare function extractEndpointLiterals(snapshot: TypeInfoFileSnapshot, stem: string): ExtractedEndpointLiterals;
+//# sourceMappingURL=extractHttpApiLiterals.d.ts.map

package/dist/internal/extractHttpApiLiterals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractHttpApiLiterals.d.ts","sourceRoot":"","sources":["../../src/internal/extractHttpApiLiterals.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAIV,oBAAoB,EAErB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAyBD;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,oBAAoB,EAC9B,IAAI,EAAE,MAAM,GACX,yBAAyB,CAiB3B"}