@typed/app 1.0.0-beta.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"httpapiId.d.ts","sourceRoot":"","sources":["../../src/internal/httpapiId.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,eAAO,MAAM,6BAA6B,SAAS,CAAC;AAEpD,MAAM,MAAM,iCAAiC,GACzC;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,EAAE,EAAE,MAAM,EACV,MAAM,GAAE,MAAsC,GAC7C,iCAAiC,CAwBnC;AAED,MAAM,MAAM,mCAAmC,GAC3C;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,MAAsC,GAC7C,mCAAmC,CAiBrC"}

package/dist/internal/httpapiId.js

@@ -0,0 +1,57 @@
+/**
+ * Parse and resolve `api:` virtual module IDs (router-plugin semantics).
+ * Used by HttpApi virtual module plugin for target-directory resolution.
+ */
+import { dirname } from "node:path";
+import { pathIsUnderBase, resolvePathUnderBase, toPosixPath } from "./path.js";
+import { validateNonEmptyString, validatePathSegment } from "./validation.js";
+export const HTTPAPI_VIRTUAL_MODULE_PREFIX = "api:";
+/**
+ * Parses an `api:./<directory>` (or `api:<directory>`) ID.
+ * Normalizes bare directory to `./<directory>`.
+ */
+export function parseHttpApiVirtualModuleId(id, prefix = HTTPAPI_VIRTUAL_MODULE_PREFIX) {
+    const idResult = validateNonEmptyString(id, "id");
+    if (!idResult.ok)
+        return { ok: false, reason: idResult.reason };
+    const prefixResult = validateNonEmptyString(prefix, "prefix");
+    if (!prefixResult.ok)
+        return { ok: false, reason: prefixResult.reason };
+    if (!id.startsWith(prefix)) {
+        return { ok: false, reason: `id must start with "${prefix}"` };
+    }
+    let relativeDirectory = id.slice(prefix.length);
+    if (relativeDirectory.length > 0 &&
+        relativeDirectory !== "." &&
+        relativeDirectory !== ".." &&
+        !relativeDirectory.startsWith("./") &&
+        !relativeDirectory.startsWith("../") &&
+        !relativeDirectory.startsWith("/")) {
+        relativeDirectory = `./${relativeDirectory}`;
+    }
+    const relativeResult = validatePathSegment(relativeDirectory, "relativeDirectory");
+    if (!relativeResult.ok)
+        return { ok: false, reason: relativeResult.reason };
+    return { ok: true, relativeDirectory: relativeResult.value };
+}
+/**
+ * Resolves the target directory for an `api:` ID relative to the importer.
+ * Rejects paths that escape the importer base directory.
+ */
+export function resolveHttpApiTargetDirectory(id, importer, prefix = HTTPAPI_VIRTUAL_MODULE_PREFIX) {
+    const parsed = parseHttpApiVirtualModuleId(id, prefix);
+    if (!parsed.ok)
+        return parsed;
+    const importerResult = validatePathSegment(importer, "importer");
+    if (!importerResult.ok)
+        return { ok: false, reason: importerResult.reason };
+    const importerDir = dirname(toPosixPath(importerResult.value));
+    const resolved = resolvePathUnderBase(importerDir, parsed.relativeDirectory);
+    if (!resolved.ok) {
+        return { ok: false, reason: "resolved target directory escapes importer base directory" };
+    }
+    if (!pathIsUnderBase(importerDir, resolved.path)) {
+        return { ok: false, reason: "resolved target directory is outside importer base directory" };
+    }
+    return { ok: true, targetDirectory: toPosixPath(resolved.path) };
+}

package/dist/internal/httpapiOpenApiConfig.d.ts

@@ -0,0 +1,87 @@
+/**
+ * OpenAPI config mapper for HttpApi virtual module plugin.
+ * Maps convention/option layers to Effect-backed surfaces:
+ * - OpenApi.annotations keys
+ * - OpenApi.fromApi additionalProperties (API scope only)
+ * - Exposure: jsonPath, swaggerPath, scalar (json/swagger/scalar modes)
+ * Scope validation and route-conflict diagnostics are applied.
+ */
+/** Supported OpenApi.annotation keys (Effect-backed). */
+export declare const OPENAPI_ANNOTATION_KEYS: readonly ["identifier", "title", "version", "description", "license", "summary", "deprecated", "externalDocs", "servers", "format", "override", "exclude", "transform"];
+export type OpenApiAnnotationKey = (typeof OPENAPI_ANNOTATION_KEYS)[number];
+export declare const OPENAPI_ANNOTATION_KEY_SET: Set<string>;
+/** Scope at which OpenAPI config is applied. */
+export type OpenApiConfigScope = "api" | "group" | "endpoint";
+/** Annotation-only config (allowed at api, group, endpoint). */
+export interface OpenApiAnnotationsConfig {
+    readonly [key: string]: unknown;
+}
+/** Spec generation options (API scope only). */
+export interface OpenApiGenerationConfig {
+    readonly additionalProperties?: boolean | Record<string, unknown>;
+}
+/** Scalar exposure config. */
+export interface OpenApiScalarExposureConfig {
+    readonly path?: `/${string}`;
+    readonly source?: "inline" | "cdn";
+    readonly version?: string;
+    readonly config?: Record<string, unknown>;
+}
+/** Exposure routes (API scope only). */
+export interface OpenApiExposureConfig {
+    readonly jsonPath?: `/${string}` | false;
+    readonly swaggerPath?: `/${string}` | false;
+    readonly scalar?: OpenApiScalarExposureConfig | false;
+}
+/** Normalized OpenAPI config after scope validation. */
+export interface NormalizedOpenApiConfig {
+    readonly annotations: OpenApiAnnotationsConfig;
+    readonly generation: OpenApiGenerationConfig;
+    readonly exposure: OpenApiExposureConfig;
+}
+/** Diagnostic for OpenAPI config validation. */
+export interface OpenApiConfigDiagnostic {
+    readonly code: string;
+    readonly message: string;
+    readonly scope?: OpenApiConfigScope;
+}
+/**
+ * Validates that generation options (e.g. additionalProperties) are only at API scope.
+ */
+export declare function validateOpenApiGenerationScope(scope: OpenApiConfigScope, generation: OpenApiGenerationConfig): OpenApiConfigDiagnostic[];
+/**
+ * Validates that exposure options (jsonPath, swaggerPath, scalar) are only at API scope.
+ */
+export declare function validateOpenApiExposureScope(scope: OpenApiConfigScope, exposure: OpenApiExposureConfig): OpenApiConfigDiagnostic[];
+/**
+ * Collects exposure route paths and detects conflicts (same path, different mode).
+ */
+export interface ExposureRouteEntry {
+    readonly path: string;
+    readonly mode: "json" | "swagger" | "scalar";
+}
+export declare function collectExposureRoutes(exposure: OpenApiExposureConfig): ExposureRouteEntry[];
+/**
+ * Detects route conflicts: same path used for more than one exposure mode.
+ */
+export declare function validateOpenApiExposureRouteConflicts(exposure: OpenApiExposureConfig): OpenApiConfigDiagnostic[];
+/**
+ * Filters raw annotation keys to Effect-supported set; emits diagnostic for unsupported keys.
+ */
+export declare function filterAnnotationKeys(raw: Record<string, unknown>): {
+    annotations: OpenApiAnnotationsConfig;
+    diagnostics: OpenApiConfigDiagnostic[];
+};
+/**
+ * Normalizes and validates OpenAPI config for API scope.
+ * Merges annotations, validates generation/exposure scope and route conflicts.
+ */
+export declare function normalizeOpenApiConfig(scope: OpenApiConfigScope, raw: {
+    annotations?: Record<string, unknown>;
+    generation?: OpenApiGenerationConfig;
+    exposure?: OpenApiExposureConfig;
+}): {
+    config: NormalizedOpenApiConfig;
+    diagnostics: OpenApiConfigDiagnostic[];
+};
+//# sourceMappingURL=httpapiOpenApiConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"httpapiOpenApiConfig.d.ts","sourceRoot":"","sources":["../../src/internal/httpapiOpenApiConfig.ts"],"names":[],"mappings":"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"}

package/dist/internal/httpapiOpenApiConfig.js

@@ -0,0 +1,144 @@
+/**
+ * OpenAPI config mapper for HttpApi virtual module plugin.
+ * Maps convention/option layers to Effect-backed surfaces:
+ * - OpenApi.annotations keys
+ * - OpenApi.fromApi additionalProperties (API scope only)
+ * - Exposure: jsonPath, swaggerPath, scalar (json/swagger/scalar modes)
+ * Scope validation and route-conflict diagnostics are applied.
+ */
+/** Supported OpenApi.annotation keys (Effect-backed). */
+export const OPENAPI_ANNOTATION_KEYS = [
+    "identifier",
+    "title",
+    "version",
+    "description",
+    "license",
+    "summary",
+    "deprecated",
+    "externalDocs",
+    "servers",
+    "format",
+    "override",
+    "exclude",
+    "transform",
+];
+export const OPENAPI_ANNOTATION_KEY_SET = new Set(OPENAPI_ANNOTATION_KEYS);
+const DIAG_SCOPE_GENERATION = "AVM-OPENAPI-001";
+const DIAG_SCOPE_EXPOSURE = "AVM-OPENAPI-002";
+const DIAG_ROUTE_CONFLICT = "AVM-OPENAPI-003";
+const DIAG_INVALID_ANNOTATION_KEY = "AVM-OPENAPI-004";
+/**
+ * Validates that generation options (e.g. additionalProperties) are only at API scope.
+ */
+export function validateOpenApiGenerationScope(scope, generation) {
+    const diagnostics = [];
+    if (scope === "api")
+        return diagnostics;
+    const hasGen = generation.additionalProperties !== undefined &&
+        (typeof generation.additionalProperties === "boolean" ||
+            (typeof generation.additionalProperties === "object" && generation.additionalProperties !== null));
+    if (hasGen) {
+        diagnostics.push({
+            code: DIAG_SCOPE_GENERATION,
+            message: "OpenAPI generation options (e.g. additionalProperties) are allowed at API scope only.",
+            scope,
+        });
+    }
+    return diagnostics;
+}
+/**
+ * Validates that exposure options (jsonPath, swaggerPath, scalar) are only at API scope.
+ */
+export function validateOpenApiExposureScope(scope, exposure) {
+    const diagnostics = [];
+    if (scope === "api")
+        return diagnostics;
+    const hasExposure = exposure.jsonPath !== undefined ||
+        exposure.swaggerPath !== undefined ||
+        exposure.scalar !== undefined;
+    if (hasExposure) {
+        diagnostics.push({
+            code: DIAG_SCOPE_EXPOSURE,
+            message: "OpenAPI exposure options (jsonPath, swaggerPath, scalar) are allowed at API scope only.",
+            scope,
+        });
+    }
+    return diagnostics;
+}
+export function collectExposureRoutes(exposure) {
+    const entries = [];
+    if (exposure.jsonPath && typeof exposure.jsonPath === "string") {
+        entries.push({ path: exposure.jsonPath, mode: "json" });
+    }
+    if (exposure.swaggerPath && typeof exposure.swaggerPath === "string") {
+        entries.push({ path: exposure.swaggerPath, mode: "swagger" });
+    }
+    if (exposure.scalar && typeof exposure.scalar === "object" && exposure.scalar.path) {
+        entries.push({ path: exposure.scalar.path, mode: "scalar" });
+    }
+    return entries;
+}
+/**
+ * Detects route conflicts: same path used for more than one exposure mode.
+ */
+export function validateOpenApiExposureRouteConflicts(exposure) {
+    const routes = collectExposureRoutes(exposure);
+    const byPath = new Map();
+    for (const { path, mode } of routes) {
+        const normalized = path.toLowerCase().replace(/\/+$/, "") || "/";
+        const list = byPath.get(normalized) ?? [];
+        list.push(mode);
+        byPath.set(normalized, list);
+    }
+    const diagnostics = [];
+    for (const [path, modes] of byPath) {
+        if (modes.length > 1) {
+            diagnostics.push({
+                code: DIAG_ROUTE_CONFLICT,
+                message: `OpenAPI exposure route conflict: path "${path}" used for multiple modes: ${[...new Set(modes)].join(", ")}`,
+            });
+        }
+    }
+    return diagnostics;
+}
+/**
+ * Filters raw annotation keys to Effect-supported set; emits diagnostic for unsupported keys.
+ */
+export function filterAnnotationKeys(raw) {
+    const annotations = {};
+    const diagnostics = [];
+    for (const [key, value] of Object.entries(raw)) {
+        if (OPENAPI_ANNOTATION_KEY_SET.has(key)) {
+            annotations[key] = value;
+        }
+        else {
+            diagnostics.push({
+                code: DIAG_INVALID_ANNOTATION_KEY,
+                message: `Unsupported OpenAPI annotation key: "${key}". Supported: ${OPENAPI_ANNOTATION_KEYS.join(", ")}`,
+            });
+        }
+    }
+    return { annotations, diagnostics };
+}
+/**
+ * Normalizes and validates OpenAPI config for API scope.
+ * Merges annotations, validates generation/exposure scope and route conflicts.
+ */
+export function normalizeOpenApiConfig(scope, raw) {
+    const diagnostics = [];
+    const { annotations: ann, diagnostics: annDiag } = filterAnnotationKeys((raw.annotations ?? {}));
+    diagnostics.push(...annDiag);
+    const generation = raw.generation ?? {};
+    diagnostics.push(...validateOpenApiGenerationScope(scope, generation));
+    const exposure = raw.exposure ?? {};
+    diagnostics.push(...validateOpenApiExposureScope(scope, exposure));
+    if (scope === "api") {
+        diagnostics.push(...validateOpenApiExposureRouteConflicts(exposure));
+    }
+    const config = {
+        annotations: ann,
+        generation,
+        exposure,
+    };
+    return { config, diagnostics };
+}

package/dist/internal/httpapiSort.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Deterministic ordering for HttpApi discovery: paths, roles, and AST nodes.
+ * Centralizes stable sort so AST nodes and file roles have consistent order.
+ */
+import type { HttpApiTreeNode } from "./httpapiDescriptorTree.js";
+import { compareHttpApiPathOrder, normalizeHttpApiRelativePath, sortHttpApiPaths } from "./httpapiFileRoles.js";
+export { compareHttpApiPathOrder, normalizeHttpApiRelativePath, sortHttpApiPaths };
+/**
+ * Stable comparison for tree nodes (by path or dirPath).
+ */
+export declare function compareHttpApiTreeNodeOrder(a: HttpApiTreeNode, b: HttpApiTreeNode): number;
+/**
+ * Returns a new array of tree nodes in deterministic order.
+ */
+export declare function sortHttpApiTreeNodes(nodes: readonly HttpApiTreeNode[]): HttpApiTreeNode[];
+//# sourceMappingURL=httpapiSort.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"httpapiSort.d.ts","sourceRoot":"","sources":["../../src/internal/httpapiSort.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EACL,uBAAuB,EACvB,4BAA4B,EAC5B,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,gBAAgB,EAAE,CAAC;AAcnF;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,MAAM,CAE1F;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,eAAe,EAAE,CAEzF"}

package/dist/internal/httpapiSort.js

@@ -0,0 +1,29 @@
+/**
+ * Deterministic ordering for HttpApi discovery: paths, roles, and AST nodes.
+ * Centralizes stable sort so AST nodes and file roles have consistent order.
+ */
+import { compareHttpApiPathOrder, normalizeHttpApiRelativePath, sortHttpApiPaths, } from "./httpapiFileRoles.js";
+export { compareHttpApiPathOrder, normalizeHttpApiRelativePath, sortHttpApiPaths };
+function nodeOrderKey(n) {
+    switch (n.type) {
+        case "endpoint":
+            return n.path;
+        case "group":
+        case "pathless_directory":
+            return n.dirPath;
+        default:
+            return "";
+    }
+}
+/**
+ * Stable comparison for tree nodes (by path or dirPath).
+ */
+export function compareHttpApiTreeNodeOrder(a, b) {
+    return compareHttpApiPathOrder(nodeOrderKey(a), nodeOrderKey(b));
+}
+/**
+ * Returns a new array of tree nodes in deterministic order.
+ */
+export function sortHttpApiTreeNodes(nodes) {
+    return [...nodes].sort(compareHttpApiTreeNodeOrder);
+}

package/dist/internal/path.d.ts

@@ -0,0 +1,16 @@
+export declare const toPosixPath: (path: string) => string;
+/** Strip the extension from a path using extname; returns path unchanged if no extension. */
+export declare const stripScriptExtension: (path: string) => string;
+export declare const resolveRelativePath: (baseDir: string, relativePath: string) => string;
+/**
+ * Resolves relativePath against baseDir and ensures the result stays under baseDir.
+ */
+export declare function resolvePathUnderBase(baseDir: string, relativePath: string): {
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    error: "path-escapes-base";
+};
+export declare function pathIsUnderBase(baseDir: string, absolutePath: string): boolean;
+//# sourceMappingURL=path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/internal/path.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,MAAoC,CAAC;AAEhF,6FAA6F;AAC7F,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,MAGnD,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,EAAE,cAAc,MAAM,KAAG,MAC/B,CAAC;AAE9C;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GACnB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,mBAAmB,CAAA;CAAE,CAQxE;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAe9E"}

package/dist/internal/path.js

@@ -0,0 +1,38 @@
+import { realpathSync } from "node:fs";
+import { extname, isAbsolute, relative, resolve } from "node:path";
+export const toPosixPath = (path) => path.replaceAll("\\", "/");
+/** Strip the extension from a path using extname; returns path unchanged if no extension. */
+export const stripScriptExtension = (path) => {
+    const ext = extname(path);
+    return ext ? path.slice(0, -ext.length) : path;
+};
+export const resolveRelativePath = (baseDir, relativePath) => toPosixPath(resolve(baseDir, relativePath));
+/**
+ * Resolves relativePath against baseDir and ensures the result stays under baseDir.
+ */
+export function resolvePathUnderBase(baseDir, relativePath) {
+    const baseAbs = resolve(baseDir);
+    const resolved = resolve(baseDir, relativePath);
+    const rel = relative(baseAbs, resolved);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+        return { ok: false, error: "path-escapes-base" };
+    }
+    return { ok: true, path: toPosixPath(resolved) };
+}
+export function pathIsUnderBase(baseDir, absolutePath) {
+    let baseAbs;
+    let resolvedAbs;
+    try {
+        baseAbs = realpathSync(resolve(baseDir));
+        resolvedAbs = realpathSync(resolve(absolutePath));
+    }
+    catch {
+        baseAbs = resolve(baseDir);
+        resolvedAbs = resolve(absolutePath);
+    }
+    const rel = relative(baseAbs, resolvedAbs);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+        return false;
+    }
+    return true;
+}

package/dist/internal/resolveConfig.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolves a config field: raw value or yield* Config.
+ * Requires ConfigProvider when value is Config.
+ */
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+export declare function resolveConfig<T>(value: T | Config.Config<T> | undefined, def: T): Effect.Effect<T, Config.ConfigError>;
+//# sourceMappingURL=resolveConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveConfig.d.ts","sourceRoot":"","sources":["../../src/internal/resolveConfig.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,wBAAgB,aAAa,CAAC,CAAC,EAC7B,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,EACvC,GAAG,EAAE,CAAC,GACL,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,WAAW,CAAC,CAItC"}

package/dist/internal/resolveConfig.js

@@ -0,0 +1,13 @@
+/**
+ * Resolves a config field: raw value or yield* Config.
+ * Requires ConfigProvider when value is Config.
+ */
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+export function resolveConfig(value, def) {
+    if (value === undefined)
+        return Effect.succeed(def);
+    if (Config.isConfig(value))
+        return value.asEffect();
+    return Effect.succeed(value);
+}

package/dist/internal/routeIdentifiers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Path relative to baseDir → valid JS identifier.
+ * Safe for special chars in filenames; never emits invalid identifiers.
+ */
+export declare function pathToIdentifier(relativeFilePath: string): string;
+/**
+ * Route module identifier: prefix with M to avoid clashing with Router/Fx/Effect/Stream.
+ */
+export declare function routeModuleIdentifier(relativeFilePath: string): string;
+/**
+ * Assign unique var names when proposed names collide (e.g. users/[id].ts and users/id.ts both → UsersId).
+ * First occurrence keeps the base name; others get base + "Param" (if path has [x]), "Literal", or numeric suffix.
+ */
+export declare function makeUniqueVarNames(entries: readonly {
+    path: string;
+    proposedName: string;
+}[]): Map<string, string>;
+//# sourceMappingURL=routeIdentifiers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routeIdentifiers.d.ts","sourceRoot":"","sources":["../../src/internal/routeIdentifiers.ts"],"names":[],"mappings":"AAaA;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAUjE;AAYD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAGtE;AAOD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,EAAE,GACzD,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAkCrB"}

package/dist/internal/routeIdentifiers.js

@@ -0,0 +1,90 @@
+import { stripScriptExtension, toPosixPath } from "./path.js";
+/**
+ * Sanitize a path segment for use in a JS identifier: strip _ and brackets, keep only [a-zA-Z0-9], capitalize.
+ * Empty after sanitization is skipped (returns "").
+ */
+function segmentToIdentifierPart(seg) {
+    let name = seg.trim().startsWith("_") ? seg.trim().slice(1) : seg.trim();
+    name = name.replace(/[[\]]/g, "").replace(/[^a-zA-Z0-9]/g, "");
+    if (!name)
+        return "";
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+/**
+ * Path relative to baseDir → valid JS identifier.
+ * Safe for special chars in filenames; never emits invalid identifiers.
+ */
+export function pathToIdentifier(relativeFilePath) {
+    const posix = toPosixPath(relativeFilePath);
+    const withoutExt = stripScriptExtension(posix);
+    const raw = withoutExt.split("/").filter(Boolean).map(segmentToIdentifierPart).filter(Boolean).join("") ||
+        "Module";
+    const safe = raw.replace(/[^a-zA-Z0-9_$]/g, "");
+    if (!safe)
+        return "Module";
+    if (/^\d/.test(safe))
+        return `M${safe}`;
+    return safe;
+}
+/** Final guard: ensure a string is a valid JS identifier (no spaces, brackets, or leading digit). */
+function toSafeIdentifier(s) {
+    const cleaned = s.replace(/[\s[\]]/g, "").replace(/[^a-zA-Z0-9_$]/g, "");
+    if (!cleaned)
+        return "Module";
+    if (/^\d/.test(cleaned))
+        return `M${cleaned}`;
+    return cleaned;
+}
+const RESERVED_NAMES = new Set(["Router", "Fx", "Effect", "Stream"]);
+/**
+ * Route module identifier: prefix with M to avoid clashing with Router/Fx/Effect/Stream.
+ */
+export function routeModuleIdentifier(relativeFilePath) {
+    const base = pathToIdentifier(relativeFilePath);
+    return RESERVED_NAMES.has(base) ? `M${base}` : base;
+}
+/** True if the path has a dynamic segment (bracket). */
+function pathHasParamSegment(relativePath) {
+    return /\[[^\]]*\]/.test(relativePath);
+}
+/**
+ * Assign unique var names when proposed names collide (e.g. users/[id].ts and users/id.ts both → UsersId).
+ * First occurrence keeps the base name; others get base + "Param" (if path has [x]), "Literal", or numeric suffix.
+ */
+export function makeUniqueVarNames(entries) {
+    const sorted = [...entries].sort((a, b) => a.path.localeCompare(b.path));
+    const nameToPaths = new Map();
+    for (const { path, proposedName } of sorted) {
+        const base = toSafeIdentifier(proposedName);
+        const list = nameToPaths.get(base) ?? [];
+        list.push(path);
+        nameToPaths.set(base, list);
+    }
+    const pathToUnique = new Map();
+    const used = new Set();
+    for (const [base, paths] of nameToPaths) {
+        for (let i = 0; i < paths.length; i++) {
+            const path = paths[i];
+            let name;
+            if (paths.length === 1) {
+                name = base;
+            }
+            else if (i === 0) {
+                name = base;
+            }
+            else {
+                const suffix = pathHasParamSegment(path) ? "Param" : "Literal";
+                let candidate = base + suffix;
+                let n = 0;
+                while (used.has(candidate)) {
+                    n += 1;
+                    candidate = base + String(n);
+                }
+                name = candidate;
+            }
+            used.add(name);
+            pathToUnique.set(path, name);
+        }
+    }
+    return pathToUnique;
+}

package/dist/internal/routeTypeNode.d.ts

@@ -0,0 +1,45 @@
+import type { ConstructorTypeNode, FunctionTypeNode, OverloadSetTypeNode, TypeInfoApi, TypeNode } from "@typed/virtual-modules";
+/** True when the node represents a callable (function, overload set, or constructor). */
+export declare function isCallableNode(node: TypeNode): node is FunctionTypeNode | OverloadSetTypeNode | ConstructorTypeNode;
+/** First signature's return type for function-like nodes; undefined otherwise. */
+export declare function getCallableReturnType(node: TypeNode): TypeNode | undefined;
+/**
+ * True iff the type is structurally assignable to Route.
+ */
+export declare function typeNodeIsRouteCompatible(node: TypeNode, api: TypeInfoApi): boolean;
+export type RuntimeKind = "fx" | "effect" | "stream" | "plain" | "unknown";
+/**
+ * Structurally determines runtime kind via api.isAssignableTo. No fallbacks.
+ * Never returns "unknown"; use callers' failWhenNoTargetsResolved for that.
+ */
+export declare function typeNodeToRuntimeKind(node: TypeNode, api: TypeInfoApi): RuntimeKind;
+/** Dependency export form for targeted .provide() lifts. */
+export type DepsExportKind = "layer" | "servicemap" | "array";
+/** Result of classifyDepsExport; "unknown" means validation must fail. */
+export type DepsExportClassification = DepsExportKind | "unknown";
+/** Classify dependency default export for optimal provide lift. Uses api; node.kind "array" for T[]. */
+export declare function classifyDepsExport(node: TypeNode, api: TypeInfoApi): DepsExportClassification;
+/** True iff the type node is a function whose first parameter expects RefSubject. */
+export declare function typeNodeExpectsRefSubjectParam(node: TypeNode, api: TypeInfoApi): boolean;
+/**
+ * True iff the function's return type is Effect and Effect's success type (first type arg) is assignable to Option.
+ */
+export declare function typeNodeIsEffectOptionReturn(node: TypeNode, api: TypeInfoApi): boolean;
+/**
+ * Classify catch handler form: native (RefSubject=>Fx), fn-cause ((Cause)=>...), fn-error ((E)=>...), or value.
+ */
+export type CatchForm = {
+    form: "native";
+    returnKind: RuntimeKind;
+} | {
+    form: "value";
+    returnKind: RuntimeKind;
+} | {
+    form: "fn-cause";
+    returnKind: RuntimeKind;
+} | {
+    form: "fn-error";
+    returnKind: RuntimeKind;
+};
+export declare function classifyCatchForm(node: TypeNode, api: TypeInfoApi): CatchForm;
+//# sourceMappingURL=routeTypeNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routeTypeNode.d.ts","sourceRoot":"","sources":["../../src/internal/routeTypeNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,QAAQ,EACT,MAAM,wBAAwB,CAAC;AAEhC,yFAAyF;AACzF,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,GACb,IAAI,IAAI,gBAAgB,GAAG,mBAAmB,GAAG,mBAAmB,CAEtE;AAeD,kFAAkF;AAClF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAQ1E;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAEnF;AAED,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;AAE3E;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,GAAG,WAAW,CAKnF;AAED,4DAA4D;AAC5D,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,YAAY,GAAG,OAAO,CAAC;AAE9D,0EAA0E;AAC1E,MAAM,MAAM,wBAAwB,GAAG,cAAc,GAAG,SAAS,CAAC;AAElE,wGAAwG;AACxG,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,WAAW,GACf,wBAAwB,CAK1B;AAED,qFAAqF;AACrF,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAKxF;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAMtF;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,UAAU,EAAE,WAAW,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,WAAW,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,WAAW,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,WAAW,CAAA;CAAE,CAAC;AAElD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,GAAG,SAAS,CAe7E"}