@typed/app 1.0.0-beta.1

package/dist/internal/routeTypeNode.js

@@ -0,0 +1,93 @@
+/** True when the node represents a callable (function, overload set, or constructor). */
+export function isCallableNode(node) {
+    return node.kind === "function" || node.kind === "overloadSet" || node.kind === "constructor";
+}
+/** First signature's parameters for function-like nodes; undefined otherwise. */
+function getCallableParameters(node) {
+    if (node.kind === "function")
+        return node.parameters;
+    if (node.kind === "overloadSet") {
+        const sigs = node.signatures;
+        return sigs[0]?.parameters;
+    }
+    if (node.kind === "constructor")
+        return node.parameters;
+    return undefined;
+}
+/** First signature's return type for function-like nodes; undefined otherwise. */
+export function getCallableReturnType(node) {
+    if (node.kind === "function")
+        return node.returnType;
+    if (node.kind === "overloadSet") {
+        const sigs = node.signatures;
+        return sigs[0]?.returnType;
+    }
+    if (node.kind === "constructor")
+        return node.returnType;
+    return undefined;
+}
+/**
+ * True iff the type is structurally assignable to Route.
+ */
+export function typeNodeIsRouteCompatible(node, api) {
+    return api.isAssignableTo(node, "Route");
+}
+/**
+ * Structurally determines runtime kind via api.isAssignableTo. No fallbacks.
+ * Never returns "unknown"; use callers' failWhenNoTargetsResolved for that.
+ */
+export function typeNodeToRuntimeKind(node, api) {
+    if (api.isAssignableTo(node, "Fx"))
+        return "fx";
+    if (api.isAssignableTo(node, "Effect"))
+        return "effect";
+    if (api.isAssignableTo(node, "Stream"))
+        return "stream";
+    return "plain";
+}
+/** Classify dependency default export for optimal provide lift. Uses api; node.kind "array" for T[]. */
+export function classifyDepsExport(node, api) {
+    if (api.isAssignableTo(node, "Layer"))
+        return "layer";
+    if (api.isAssignableTo(node, "ServiceMap"))
+        return "servicemap";
+    if (node.kind === "array")
+        return "array";
+    return "unknown";
+}
+/** True iff the type node is a function whose first parameter expects RefSubject. */
+export function typeNodeExpectsRefSubjectParam(node, api) {
+    if (!isCallableNode(node))
+        return false;
+    const params = getCallableParameters(node);
+    if (!params || params.length === 0)
+        return false;
+    return api.isAssignableTo(node, "RefSubject", [{ kind: "param", index: 0 }]);
+}
+/**
+ * True iff the function's return type is Effect and Effect's success type (first type arg) is assignable to Option.
+ */
+export function typeNodeIsEffectOptionReturn(node, api) {
+    return api.isAssignableTo(node, "Option", [
+        { kind: "returnType" },
+        { kind: "ensure", targetId: "Effect" },
+        { kind: "typeArg", index: 0 },
+    ]);
+}
+export function classifyCatchForm(node, api) {
+    const returnType = getCallableReturnType(node);
+    const returnKind = returnType
+        ? typeNodeToRuntimeKind(returnType, api)
+        : typeNodeToRuntimeKind(node, api);
+    if (!isCallableNode(node)) {
+        return { form: "value", returnKind };
+    }
+    const params = getCallableParameters(node);
+    if (!params || params.length === 0)
+        return { form: "fn-error", returnKind };
+    if (api.isAssignableTo(node, "RefSubject", [{ kind: "param", index: 0 }]))
+        return { form: "native", returnKind };
+    if (api.isAssignableTo(node, "Cause", [{ kind: "param", index: 0 }]))
+        return { form: "fn-cause", returnKind };
+    return { form: "fn-error", returnKind };
+}

package/dist/internal/routerDescriptorTree.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Declarative descriptor tree for router virtual module emission.
+ * Describes ALL route structure and metadata; rendering is a separate phase.
+ *
+ * Optimizations in renderer:
+ * - Router.merge only when 2+ siblings
+ * - No Router.merge() for single child
+ * - Parens only when chaining on multi-arg call expressions
+ * - Positional match when no extra opts
+ */
+import type { CatchForm, DepsExportKind, RuntimeKind } from "./routeTypeNode.js";
+/** Resolved companion paths per concern (guard, deps, layout, catch). */
+export type ComposedConcernsShape = {
+    readonly guard: readonly string[];
+    readonly dependencies: readonly string[];
+    readonly layout: readonly string[];
+    readonly catch: readonly string[];
+};
+/** Path-based refs (relative to baseDir); var names resolved at render time. */
+export type PathRef = string;
+/** Per-route match configuration (declarative, path-based). */
+export type RouteMatchDescriptor = {
+    readonly routePath: PathRef;
+    readonly entrypointExport: "handler" | "template" | "default";
+    readonly runtimeKind: RuntimeKind;
+    readonly entrypointIsFunction: boolean;
+    readonly entrypointExpectsRefSubject: boolean;
+    readonly inFileConcerns: {
+        readonly layout?: boolean;
+        readonly dependencies?: boolean;
+        readonly catch?: boolean;
+        readonly guard?: boolean;
+    };
+    readonly composedConcerns: ComposedConcernsShape;
+    /** Guard from in-file, sibling, or directory (path). */
+    readonly guardPath?: PathRef;
+    /** Catch from in-file or sibling (path). */
+    readonly catchPath?: PathRef;
+    readonly catchExport?: "catch" | "catchFn";
+    readonly catchForm?: CatchForm;
+    /** Layout from in-file or sibling (path). */
+    readonly layoutPath?: PathRef;
+    /** Dependencies from in-file or sibling (path). */
+    readonly depsPath?: PathRef;
+};
+/** Directory companions (path-based). */
+export type DirectoryCompanions = {
+    readonly layout?: PathRef;
+    readonly catch?: PathRef;
+    readonly dependencies?: PathRef;
+};
+/** Declarative tree node: route leaf or directory with children. */
+export type RouterDescriptorNode = {
+    readonly type: "route";
+    readonly match: RouteMatchDescriptor;
+} | {
+    readonly type: "directory";
+    readonly dirPath: string;
+    readonly children: readonly RouterDescriptorNode[];
+    readonly companions?: DirectoryCompanions;
+};
+/** Root descriptor tree. */
+export type RouterDescriptorTree = {
+    readonly root: RouterDescriptorNode;
+    readonly rootCompanions?: Pick<DirectoryCompanions, "dependencies">;
+};
+/** Input for building the descriptor tree from route descriptors. */
+export type BuildDescriptorTreeInput = {
+    readonly descriptors: readonly {
+        readonly filePath: string;
+        readonly entrypointExport: "handler" | "template" | "default";
+        readonly runtimeKind: RuntimeKind;
+        readonly entrypointIsFunction: boolean;
+        readonly entrypointExpectsRefSubject: boolean;
+        readonly composedConcerns: ComposedConcernsShape;
+        readonly inFileConcerns: {
+            layout?: boolean;
+            dependencies?: boolean;
+            catch?: boolean;
+            guard?: boolean;
+        };
+    }[];
+    readonly dirToCompanions: ReadonlyMap<string, {
+        layout?: string;
+        dependencies?: string;
+        catch?: string;
+    }>;
+    readonly guardExportByPath: Readonly<Record<string, "default" | "guard">>;
+    readonly catchExportByPath: Readonly<Record<string, "catch" | "catchFn">>;
+    readonly catchFormByPath: Readonly<Record<string, CatchForm>>;
+    readonly normalizeDir: (dir: string) => string;
+    readonly isDirectoryCompanion: (path: string) => boolean;
+    readonly siblingCompanionPath: (leafPath: string, kind: "guard" | "dependencies" | "layout" | "catch") => string;
+};
+/** Build declarative tree from route descriptors. */
+export declare function buildRouterDescriptorTree(input: BuildDescriptorTreeInput): RouterDescriptorTree;
+/** Context for rendering: var names and expr generators. */
+export type RenderContext = {
+    readonly varNameByPath: ReadonlyMap<string, string>;
+    readonly guardExportByPath: Readonly<Record<string, "default" | "guard">>;
+    readonly catchExportByPath: Readonly<Record<string, "catch" | "catchFn">>;
+    readonly catchFormByPath: Readonly<Record<string, CatchForm>>;
+    readonly depsFormByPath: Readonly<Record<string, DepsExportKind>>;
+    readonly handlerExprFor: (match: RouteMatchDescriptor, varName: string) => string;
+    readonly catchExprFor: (form: CatchForm, varName: string, exportName: string) => string;
+    readonly depsExprFor: (kind: DepsExportKind, varName: string) => string;
+};
+/** Render tree to source. Optimizes: no merge for single child, minimal parens. */
+export declare function renderRouterDescriptorTree(tree: RouterDescriptorTree, ctx: RenderContext): string;
+//# sourceMappingURL=routerDescriptorTree.d.ts.map

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

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

package/dist/internal/routerDescriptorTree.js

@@ -0,0 +1,230 @@
+/**
+ * Declarative descriptor tree for router virtual module emission.
+ * Describes ALL route structure and metadata; rendering is a separate phase.
+ *
+ * Optimizations in renderer:
+ * - Router.merge only when 2+ siblings
+ * - No Router.merge() for single child
+ * - Parens only when chaining on multi-arg call expressions
+ * - Positional match when no extra opts
+ */
+/** Build declarative tree from route descriptors. */
+export function buildRouterDescriptorTree(input) {
+    const { descriptors, dirToCompanions, catchExportByPath, catchFormByPath, normalizeDir, isDirectoryCompanion, siblingCompanionPath, } = input;
+    const toMatchDescriptor = (d) => {
+        const sibling = (k) => siblingCompanionPath(d.filePath, k);
+        const hasSibling = (k) => d.composedConcerns[k].includes(sibling(k));
+        const dirGuardPath = d.composedConcerns.guard.find(isDirectoryCompanion);
+        const guardPath = d.inFileConcerns.guard
+            ? d.filePath
+            : hasSibling("guard")
+                ? sibling("guard")
+                : dirGuardPath;
+        const catchPath = d.inFileConcerns.catch
+            ? d.filePath
+            : hasSibling("catch")
+                ? sibling("catch")
+                : undefined;
+        return {
+            routePath: d.filePath,
+            entrypointExport: d.entrypointExport,
+            runtimeKind: d.runtimeKind,
+            entrypointIsFunction: d.entrypointIsFunction,
+            entrypointExpectsRefSubject: d.entrypointExpectsRefSubject,
+            inFileConcerns: d.inFileConcerns,
+            composedConcerns: d.composedConcerns,
+            guardPath,
+            catchPath,
+            catchExport: catchPath
+                ? (() => {
+                    const exp = catchExportByPath[catchPath];
+                    if (!exp)
+                        throw new Error(`RVM: catch export missing for ${catchPath}`);
+                    return exp;
+                })()
+                : undefined,
+            catchForm: catchPath
+                ? (() => {
+                    const form = catchFormByPath[catchPath];
+                    if (!form)
+                        throw new Error(`RVM: catch form missing for ${catchPath}`);
+                    return form;
+                })()
+                : undefined,
+            layoutPath: d.inFileConcerns.layout
+                ? d.filePath
+                : hasSibling("layout")
+                    ? sibling("layout")
+                    : undefined,
+            depsPath: d.inFileConcerns.dependencies
+                ? d.filePath
+                : hasSibling("dependencies")
+                    ? sibling("dependencies")
+                    : undefined,
+        };
+    };
+    const allDirs = new Set(descriptors.map((d) => normalizeDir(dirname(d.filePath))));
+    for (const [dir] of dirToCompanions)
+        allDirs.add(dir);
+    if (allDirs.size > 0)
+        allDirs.add("");
+    const sortedDirs = [...allDirs].sort((a, b) => b.split("/").filter(Boolean).length - a.split("/").filter(Boolean).length);
+    const dirNodeByPath = new Map();
+    for (const dir of sortedDirs) {
+        const directRoutes = descriptors.filter((d) => normalizeDir(dirname(d.filePath)) === dir);
+        const isImmediateChild = (s) => s !== dir &&
+            (dir === ""
+                ? s.indexOf("/") === -1
+                : s.startsWith(dir + "/") && s.slice((dir + "/").length).indexOf("/") === -1);
+        const childDirs = sortedDirs.filter(isImmediateChild);
+        const routeChildren = directRoutes.map((d) => ({
+            type: "route",
+            match: toMatchDescriptor(d),
+        }));
+        const dirChildren = childDirs.map((s) => dirNodeByPath.get(s));
+        const children = [...routeChildren, ...dirChildren];
+        const companions = dirToCompanions.get(dir);
+        const hasCompanions = companions &&
+            (companions.layout || companions.catch || (dir !== "" && companions.dependencies));
+        const node = children.length === 0
+            ? {
+                type: "directory",
+                dirPath: dir,
+                children: [],
+                companions: hasCompanions
+                    ? {
+                        layout: companions.layout,
+                        catch: companions.catch,
+                        dependencies: dir !== "" ? companions.dependencies : undefined,
+                    }
+                    : undefined,
+            }
+            : children.length === 1 && !hasCompanions
+                ? children[0]
+                : {
+                    type: "directory",
+                    dirPath: dir,
+                    children,
+                    companions: hasCompanions
+                        ? {
+                            layout: companions.layout,
+                            catch: companions.catch,
+                            dependencies: dir !== "" ? companions.dependencies : undefined,
+                        }
+                        : undefined,
+                };
+        dirNodeByPath.set(dir, node);
+    }
+    let root = dirNodeByPath.get("");
+    if (!root || (root.type === "directory" && root.children.length === 0)) {
+        const flatChildren = descriptors.map((d) => ({
+            type: "route",
+            match: toMatchDescriptor(d),
+        }));
+        root =
+            flatChildren.length === 0
+                ? { type: "directory", dirPath: "", children: [] }
+                : flatChildren.length === 1
+                    ? flatChildren[0]
+                    : { type: "directory", dirPath: "", children: flatChildren };
+    }
+    const rootCompanions = dirToCompanions.get("");
+    return {
+        root,
+        rootCompanions: rootCompanions?.dependencies
+            ? { dependencies: rootCompanions.dependencies }
+            : undefined,
+    };
+}
+function dirname(p) {
+    const i = p.lastIndexOf("/");
+    return i < 0 ? "" : p.slice(0, i);
+}
+/** Render tree to source. Optimizes: no merge for single child, minimal parens. */
+export function renderRouterDescriptorTree(tree, ctx) {
+    const emit = (node) => {
+        if (node.type === "route") {
+            return emitRoute(node.match, ctx);
+        }
+        const { children, companions } = node;
+        let inner;
+        if (children.length === 0) {
+            throw new Error("RVM: directory node with no children should not be rendered");
+        }
+        if (children.length === 1) {
+            inner = emit(children[0]);
+        }
+        else {
+            inner = `Router.merge(\n  ${children.map((c) => emit(c)).join(",\n  ")}\n)`;
+        }
+        if (companions?.layout) {
+            const v = ctx.varNameByPath.get(companions.layout);
+            inner = `${inner}.layout(${v}.layout)`;
+        }
+        if (companions?.catch) {
+            const v = ctx.varNameByPath.get(companions.catch);
+            const exp = ctx.catchExportByPath[companions.catch];
+            if (!exp)
+                throw new Error(`RVM: catch export missing for ${companions.catch}`);
+            const form = ctx.catchFormByPath[companions.catch];
+            if (!form)
+                throw new Error(`RVM: catch form missing for ${companions.catch}`);
+            const catchExpr = ctx.catchExprFor(form, v, exp);
+            inner = `${inner}.catchCause(${catchExpr})`;
+        }
+        if (companions?.dependencies) {
+            const v = ctx.varNameByPath.get(companions.dependencies);
+            const depsKind = ctx.depsFormByPath[companions.dependencies];
+            if (depsKind === undefined)
+                throw new Error(`RVM: dependency form unknown for ${companions.dependencies}; validation should have failed (RVM-DEPS-001)`);
+            const depsExpr = ctx.depsExprFor(depsKind, v);
+            inner = `${inner}.provide(${depsExpr})`;
+        }
+        return inner;
+    };
+    let result = emit(tree.root);
+    if (tree.rootCompanions?.dependencies) {
+        const v = ctx.varNameByPath.get(tree.rootCompanions.dependencies);
+        const depsKind = ctx.depsFormByPath[tree.rootCompanions.dependencies];
+        if (depsKind === undefined)
+            throw new Error(`RVM: dependency form unknown for ${tree.rootCompanions.dependencies}; validation should have failed (RVM-DEPS-001)`);
+        const depsExpr = ctx.depsExprFor(depsKind, v);
+        result = `${result}.provide(${depsExpr})`;
+    }
+    return result;
+}
+/** Emit Router.match(...) for a route. Favors positional when no extra opts. */
+function emitRoute(match, ctx) {
+    const routeVar = ctx.varNameByPath.get(match.routePath);
+    const routeRef = `${routeVar}.route`;
+    const handlerExpr = ctx.handlerExprFor(match, routeVar);
+    const hasExtraOpts = match.layoutPath || match.depsPath || match.catchPath;
+    const guardPath = match.guardPath;
+    const guardExport = guardPath ? ctx.guardExportByPath[guardPath] : undefined;
+    const guardExpr = guardPath && guardExport ? `${ctx.varNameByPath.get(guardPath)}.${guardExport}` : undefined;
+    const opts = [`handler: ${handlerExpr}`];
+    if (match.depsPath) {
+        opts.push(`dependencies: ${ctx.varNameByPath.get(match.depsPath)}.dependencies`);
+    }
+    if (match.layoutPath) {
+        opts.push(`layout: ${ctx.varNameByPath.get(match.layoutPath)}.layout`);
+    }
+    if (match.catchPath && match.catchExport) {
+        const catchVar = ctx.varNameByPath.get(match.catchPath);
+        const form = match.catchForm;
+        if (!form)
+            throw new Error(`RVM: catch form missing for ${match.catchPath}`);
+        opts.push(`catch: ${ctx.catchExprFor(form, catchVar, match.catchExport)}`);
+    }
+    if (guardExpr && !hasExtraOpts) {
+        return `Router.match(${routeRef}, ${guardExpr}, ${handlerExpr})`;
+    }
+    if (guardExpr && hasExtraOpts) {
+        opts.unshift(`guard: ${guardExpr}`);
+        return `Router.match(${routeRef}, ${guardExpr}, { ${opts.join(", ")} })`;
+    }
+    if (!hasExtraOpts) {
+        return `Router.match(${routeRef}, ${handlerExpr})`;
+    }
+    return `Router.match(${routeRef}, { ${opts.join(", ")} })`;
+}

package/dist/internal/typeTargetBootstrap.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=typeTargetBootstrap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typeTargetBootstrap.d.ts","sourceRoot":"","sources":["../../src/internal/typeTargetBootstrap.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,CAAC"}

package/dist/internal/typeTargetBootstrap.js

@@ -0,0 +1,23 @@
+/**
+ * Bootstrap file for TypeInfoApi type target resolution in tests.
+ * Exists so resolveTypeTargetsFromSpecs can find canonical Effect/Fx/RefSubject/Stream/Route types
+ * when the program includes this file. Do not use; for test harness only.
+ */
+import * as Effect from "effect/Effect";
+import * as Fx from "@typed/fx/Fx";
+import * as RefSubject from "@typed/fx/RefSubject";
+import * as Stream from "effect/Stream";
+import * as Route from "@typed/router";
+import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import * as Layer from "effect/Layer";
+import * as ServiceMap from "effect/ServiceMap";
+void Effect;
+void Fx;
+void RefSubject;
+void Stream;
+void Route;
+void Option;
+void Cause;
+void Layer;
+void ServiceMap;

package/dist/internal/typeTargetBootstrapHttpApi.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=typeTargetBootstrapHttpApi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typeTargetBootstrapHttpApi.d.ts","sourceRoot":"","sources":["../../src/internal/typeTargetBootstrapHttpApi.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,CAAC"}

package/dist/internal/typeTargetBootstrapHttpApi.js

@@ -0,0 +1,21 @@
+/**
+ * Bootstrap file for TypeInfoApi type target resolution in HttpApi tests.
+ * Exists so resolveTypeTargetsFromSpecs can find canonical HttpApi/Route/Effect/Schema types
+ * when the program includes this file. Do not use; for test harness only.
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Route from "@typed/router";
+import * as HttpApiModule from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiGroupModule from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiEndpointModule from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiBuilderModule from "effect/unstable/httpapi/HttpApiBuilder";
+import * as HttpServerResponseModule from "effect/unstable/http/HttpServerResponse";
+void Effect;
+void Schema;
+void Route;
+void HttpApiModule;
+void HttpApiGroupModule;
+void HttpApiEndpointModule;
+void HttpApiBuilderModule;
+void HttpServerResponseModule;

package/dist/internal/typeTargetSpecs.d.ts

@@ -0,0 +1,15 @@
+import type { TypeTargetSpec } from "@typed/virtual-modules";
+/**
+ * Type target specs for router virtual module structural validation.
+ * Pass to createTypeInfoApiSession typeTargetSpecs option.
+ *
+ * IMPORTANT: Each spec's `module` must exactly match the import string in user source.
+ * Specs are canonical-only (no fallbacks or alternate import paths).
+ */
+export declare const ROUTER_TYPE_TARGET_SPECS: readonly TypeTargetSpec[];
+/**
+ * Type target specs for HttpApi virtual module structural validation.
+ * Pass to createTypeInfoApiSession typeTargetSpecs option.
+ */
+export declare const HTTPAPI_TYPE_TARGET_SPECS: readonly TypeTargetSpec[];
+//# sourceMappingURL=typeTargetSpecs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typeTargetSpecs.d.ts","sourceRoot":"","sources":["../../src/internal/typeTargetSpecs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,SAAS,cAAc,EAU7D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,SAAS,cAAc,EAS9D,CAAC"}

package/dist/internal/typeTargetSpecs.js

@@ -0,0 +1,32 @@
+/**
+ * Type target specs for router virtual module structural validation.
+ * Pass to createTypeInfoApiSession typeTargetSpecs option.
+ *
+ * IMPORTANT: Each spec's `module` must exactly match the import string in user source.
+ * Specs are canonical-only (no fallbacks or alternate import paths).
+ */
+export const ROUTER_TYPE_TARGET_SPECS = [
+    { id: "Fx", module: "@typed/fx/Fx", exportName: "Fx" },
+    { id: "Effect", module: "effect/Effect", exportName: "Effect" },
+    { id: "Stream", module: "effect/Stream", exportName: "Stream" },
+    { id: "RefSubject", module: "@typed/fx/RefSubject", exportName: "RefSubject" },
+    { id: "Cause", module: "effect/Cause", exportName: "Cause" },
+    { id: "Option", module: "effect/Option", exportName: "Option" },
+    { id: "Layer", module: "effect/Layer", exportName: "Layer" },
+    { id: "ServiceMap", module: "effect/ServiceMap", exportName: "ServiceMap" },
+    { id: "Route", module: "@typed/router", exportName: "Route" },
+];
+/**
+ * Type target specs for HttpApi virtual module structural validation.
+ * Pass to createTypeInfoApiSession typeTargetSpecs option.
+ */
+export const HTTPAPI_TYPE_TARGET_SPECS = [
+    { id: "HttpApi", module: "effect/unstable/httpapi/HttpApi", exportName: "HttpApi" },
+    { id: "HttpApiGroup", module: "effect/unstable/httpapi/HttpApiGroup", exportName: "HttpApiGroup" },
+    { id: "HttpApiEndpoint", module: "effect/unstable/httpapi/HttpApiEndpoint", exportName: "HttpApiEndpoint" },
+    { id: "HttpApiBuilder", module: "effect/unstable/httpapi/HttpApiBuilder", exportName: "HttpApiBuilder" },
+    { id: "Schema", module: "effect/Schema", exportName: "Top" },
+    { id: "Effect", module: "effect/Effect", exportName: "Effect" },
+    { id: "Route", module: "@typed/router", exportName: "Route" },
+    { id: "HttpServerResponse", module: "effect/unstable/http/HttpServerResponse", exportName: "HttpServerResponse" },
+];

package/dist/internal/validation.d.ts

@@ -0,0 +1,12 @@
+export type ValidationOk<T> = {
+    ok: true;
+    value: T;
+};
+export type ValidationFail = {
+    ok: false;
+    reason: string;
+};
+export type ValidationResult<T> = ValidationOk<T> | ValidationFail;
+export declare function validateNonEmptyString(value: unknown, name: string, maxLength?: number): ValidationResult<string>;
+export declare function validatePathSegment(value: unknown, name: string, maxLength?: number): ValidationResult<string>;
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/internal/validation.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAAC;AACrD,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3D,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC;AAEnE,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,MAA2B,GACrC,gBAAgB,CAAC,MAAM,CAAC,CAe1B;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,MAA2B,GACrC,gBAAgB,CAAC,MAAM,CAAC,CAc1B"}

package/dist/internal/validation.js

@@ -0,0 +1,32 @@
+const DEFAULT_MAX_LENGTH = 4096;
+export function validateNonEmptyString(value, name, maxLength = DEFAULT_MAX_LENGTH) {
+    if (typeof value !== "string") {
+        return { ok: false, reason: `${name} must be a string` };
+    }
+    const trimmed = value.trim();
+    if (trimmed === "") {
+        return { ok: false, reason: `${name} must be non-empty` };
+    }
+    if (value.includes("\0")) {
+        return { ok: false, reason: `${name} must not contain null bytes` };
+    }
+    if (value.length > maxLength) {
+        return { ok: false, reason: `${name} exceeds max length ${maxLength}` };
+    }
+    return { ok: true, value: trimmed };
+}
+export function validatePathSegment(value, name, maxLength = DEFAULT_MAX_LENGTH) {
+    if (typeof value !== "string") {
+        return { ok: false, reason: `${name} must be a string` };
+    }
+    if (value.length === 0 || value.trim() === "") {
+        return { ok: false, reason: `${name} must be non-empty` };
+    }
+    if (value.includes("\0")) {
+        return { ok: false, reason: `${name} must not contain null bytes` };
+    }
+    if (value.length > maxLength) {
+        return { ok: false, reason: `${name} exceeds max length ${maxLength}` };
+    }
+    return { ok: true, value };
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@typed/app",
+  "version": "1.0.0-beta.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "[ -d dist ] || rm -f tsconfig.tsbuildinfo; tsc",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "test": "vitest run --passWithNoTests",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@typed/router": "workspace:*",
+    "@typed/virtual-modules": "workspace:*",
+    "effect": "catalog:"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "catalog:",
+    "@typed/fx": "workspace:*",
+    "@types/node": "^25.3.0",
+    "@vitest/coverage-v8": "^4.0.0",
+    "effect": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "peerDependencies": {
+    "typescript": "catalog:"
+  },
+  "files": [
+    "dist",
+    "src"
+  ]
+}