@primate/core 0.8.8 → 0.9.0

package/lib/private/client/navigate.d.ts

@@ -1,3 +1,4 @@
+declare const scroll_hash: (hash: string) => void;
 type Location = {
     hash: string;
     pathname: string;
@@ -8,7 +9,7 @@ declare function go(href: string, event?: Event): Promise<void>;
 declare const navigate: {
     go: typeof go;
     goto: typeof goto;
-    scroll_hash: (hash: string) => void;
+    scroll_hash: typeof scroll_hash;
 };
 export default navigate;
 //# sourceMappingURL=navigate.d.ts.map

package/lib/private/config/schema.d.ts

@@ -8,8 +8,8 @@ declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
     readonly http: {
         csp: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").ArrayType<import("pema").StringType, undefined>, undefined>>;
         headers: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").StringType, undefined>>;
-        host: import("pema").DefaultType<import("pema").StringType, "localhost">;
-        port: import("pema").DefaultType<import("pema").UintType<"u32", undefined>, 6161>;
+        host: import("pema").DefaultType<import("pema").StringType, string>;
+        port: import("pema").DefaultType<import("pema").UintType<"u32", undefined>, number>;
         ssl: {
             cert: import("pema").OptionalType<import("pema").StringType>;
             key: import("pema").OptionalType<import("pema").StringType>;

package/lib/private/config/schema.js

@@ -1,11 +1,12 @@
+import env from "@rcompat/env";
 import p from "pema";
 export default p({
     conditions: p.array(p.string).unique().default([]),
     http: {
         csp: p.dict(p.array(p.string)).optional(),
         headers: p.dict().optional(),
-        host: p.string.default("localhost"),
-        port: p.uint.port().default(6161),
+        host: p.string.default(() => env.try("HOST") ?? "localhost"),
+        port: p.uint.port().default(() => +(env.try("PORT") ?? 6161)),
         ssl: {
             cert: p.string.optional(),
             key: p.string.optional(),

package/lib/private/db/test.js

@@ -153,6 +153,7 @@ export default (db) => {
         },
     });
     const USER_STORES = [User, UserN, UserB];
+    const Status = p.enum({ UNCONFIRMED: 0, CONFIRMED: 1 });
     const Type = store({
         table: "type",
         db,
@@ -175,6 +176,7 @@ export default (db) => {
             u64: p.u64.optional(),
             u8: p.u8.optional(),
             json: p.json().optional(),
+            status: Status.optional(),
         },
     });
     // this stresses identifier quoting in CREATE/INSERT/SELECT/UPDATE/DELETE
@@ -678,6 +680,51 @@ export default (db) => {
             assert((await Type.get(t.id))[any(k)]).equals(ub);
         });
     });
+    $type("enum: stores and retrieves by underlying value", async (assert) => {
+        const t = await Type.insert({ status: Status.CONFIRMED });
+        assert(t.status).equals(1);
+        assert((await Type.get(t.id)).status).equals(1);
+    });
+    $type("enum: round-trips both declared members", async (assert) => {
+        const u = await Type.insert({ status: Status.UNCONFIRMED });
+        const c = await Type.insert({ status: Status.CONFIRMED });
+        assert((await Type.get(u.id)).status).equals(0);
+        assert((await Type.get(c.id)).status).equals(1);
+    });
+    $type("enum: update changes stored value", async (assert) => {
+        const t = await Type.insert({ status: Status.UNCONFIRMED });
+        await Type.update(t.id, { set: { status: Status.CONFIRMED } });
+        assert((await Type.get(t.id)).status).equals(Status.CONFIRMED);
+    });
+    $type("enum: rejects value outside declared set", async (assert) => {
+        try {
+            // 2 is a valid u8 but not a declared enum member
+            await Type.insert({ status: 2 });
+            assert("[did not throw]").equals("[threw]");
+        }
+        catch (e) {
+            assert(e.message).type();
+        }
+    });
+    $type("enum: nameOf resolves stored value to its key", async (assert) => {
+        const t = await Type.insert({ status: Status.CONFIRMED });
+        const got = await Type.get(t.id);
+        assert(Status.nameOf(got.status)).equals("CONFIRMED");
+    });
+    $type("enum: optional field can be omitted", async (assert) => {
+        const t = await Type.insert({ string: "no-status" });
+        assert(t.status).undefined();
+        assert((await Type.get(t.id)).status).undefined();
+    });
+    $type("enum: where clause matches on underlying value", async (assert) => {
+        await Type.insert({ string: "enum-where", status: Status.CONFIRMED });
+        await Type.insert({ string: "enum-where", status: Status.UNCONFIRMED });
+        const confirmed = await Type.find({
+            where: { string: "enum-where", status: Status.CONFIRMED },
+        });
+        assert(confirmed.length).equals(1);
+        assert(confirmed[0].status).equals(Status.CONFIRMED);
+    });
     [64n, 128n].forEach(i => {
         $type(`i${i}`, async (assert) => {
             const k = `i${i}`;

package/lib/private/errors.d.ts

@@ -15,6 +15,7 @@ declare function build_body_requires_content_type(): import("@rcompat/error").Te
 declare function build_unrecognized_loader(seen: string): import("@rcompat/error").TemplateError;
 declare function build_path_schema_mismatch(route: string, method: string, expected: string[], declared: string[]): import("@rcompat/error").TemplateError;
 declare function build_reserved_entrypoints(conflicts: string[]): import("@rcompat/error").TemplateError;
+declare function build_duplicate_route_page(route: string): import("@rcompat/error").TemplateError;
 declare function config_file_missing(): import("@rcompat/error").TemplateError;
 declare function config_file_empty(file: FileRef): import("@rcompat/error").TemplateError;
 declare function config_file_error(file: FileRef, cause: Error): import("@rcompat/error").TemplateError;
@@ -28,6 +29,8 @@ declare function request_body_already_parsed(): import("@rcompat/error").Templat
 declare function request_bag_missing_key(bag: string, key: string): import("@rcompat/error").TemplateError;
 declare function request_content_type_mismatch(expected: MIMEValue, actual: string): import("@rcompat/error").TemplateError;
 declare function response_invalid_body(body: string): import("@rcompat/error").TemplateError;
+declare function response_page_context_missing(): import("@rcompat/error").TemplateError;
+declare function response_page_missing(route: string): import("@rcompat/error").TemplateError;
 declare function hook_route_functions_not_allowed(file: string): import("@rcompat/error").TemplateError;
 declare function hook_not_allowed(file: string): import("@rcompat/error").TemplateError;
 declare function hook_unused(file: string): import("@rcompat/error").TemplateError;
@@ -64,6 +67,7 @@ declare const errors: {
     build_unrecognized_loader: typeof build_unrecognized_loader;
     build_path_schema_mismatch: typeof build_path_schema_mismatch;
     build_reserved_entrypoints: typeof build_reserved_entrypoints;
+    build_duplicate_route_page: typeof build_duplicate_route_page;
     config_file_missing: typeof config_file_missing;
     config_missing: typeof config_missing;
     config_file_empty: typeof config_file_empty;
@@ -77,6 +81,8 @@ declare const errors: {
     request_bag_missing_key: typeof request_bag_missing_key;
     request_content_type_mismatch: typeof request_content_type_mismatch;
     response_invalid_body: typeof response_invalid_body;
+    response_page_context_missing: typeof response_page_context_missing;
+    response_page_missing: typeof response_page_missing;
     hook_route_functions_not_allowed: typeof hook_route_functions_not_allowed;
     hook_not_allowed: typeof hook_not_allowed;
     hook_unused: typeof hook_unused;
@@ -114,6 +120,7 @@ export declare const Code: {
     build_unrecognized_loader: "build_unrecognized_loader";
     build_path_schema_mismatch: "build_path_schema_mismatch";
     build_reserved_entrypoints: "build_reserved_entrypoints";
+    build_duplicate_route_page: "build_duplicate_route_page";
     config_file_missing: "config_file_missing";
     config_missing: "config_missing";
     config_file_empty: "config_file_empty";
@@ -127,6 +134,8 @@ export declare const Code: {
     request_bag_missing_key: "request_bag_missing_key";
     request_content_type_mismatch: "request_content_type_mismatch";
     response_invalid_body: "response_invalid_body";
+    response_page_context_missing: "response_page_context_missing";
+    response_page_missing: "response_page_missing";
     hook_route_functions_not_allowed: "hook_route_functions_not_allowed";
     hook_not_allowed: "hook_not_allowed";
     hook_unused: "hook_unused";

package/lib/private/errors.js

@@ -43,6 +43,9 @@ function build_path_schema_mismatch(route, method, expected, declared) {
 function build_reserved_entrypoints(conflicts) {
     return t `entrypoint name(s) reserved: ${conflicts.map(n => `"${n}"`).join(", ")}`;
 }
+function build_duplicate_route_page(route) {
+    return t `multiple pages found for route ${route}`;
+}
 const BUILD = error.coded({
     build_missing_binary_addon,
     build_missing_route,
@@ -53,6 +56,7 @@ const BUILD = error.coded({
     build_unrecognized_loader,
     build_path_schema_mismatch,
     build_reserved_entrypoints,
+    build_duplicate_route_page,
 });
 function config_file_missing() {
     return t `missing ${"config/app.ts"}`;
@@ -114,8 +118,16 @@ const REQUEST = error.coded({
 function response_invalid_body(body) {
     return t `invalid body ${body} returned from route`;
 }
+function response_page_context_missing() {
+    return t `${"response.page"} requires a route context`;
+}
+function response_page_missing(route) {
+    return t `no page found for route ${route}`;
+}
 const RESPONSE = error.coded({
     response_invalid_body,
+    response_page_context_missing,
+    response_page_missing,
 });
 function hook_route_functions_not_allowed(file) {
     return t `${file}: route functions may not be used inside +hook files`;

package/lib/private/events.d.ts

@@ -0,0 +1,11 @@
+type Listener<Event> = (event: Event) => void;
+type Channel<Key, Event> = Readonly<{
+    emit(key: Key, event: Event): void;
+    subscribe(key: Key, listener: Listener<Event>): () => void;
+}>;
+declare function channel<Key, Event>(): Channel<Key, Event>;
+declare const events: {
+    channel: typeof channel;
+};
+export default events;
+//# sourceMappingURL=events.d.ts.map

package/lib/private/events.js

@@ -0,0 +1,24 @@
+function channel() {
+    const listeners = new Map();
+    return {
+        emit(key, event) {
+            for (const listener of [...listeners.get(key) ?? []])
+                listener(event);
+        },
+        subscribe(key, listener) {
+            const set = listeners.get(key) ?? new Set();
+            set.add(listener);
+            listeners.set(key, set);
+            return () => {
+                set.delete(listener);
+                if (set.size === 0)
+                    listeners.delete(key);
+            };
+        },
+    };
+}
+const events = {
+    channel,
+};
+export default events;
+//# sourceMappingURL=events.js.map

package/lib/private/frontend.js

@@ -144,17 +144,19 @@ export default function frontend_module(init) {
                         (app.mode !== "development" || !init.client);
                     const compile_server = init.compile?.server;
                     const compile_client = init.compile?.client;
-                    // prebuild
-                    extensions.forEach(e => {
-                        app.bind(e, async (file, { context }) => {
-                            if (context === "views" && !build_ssr)
+                    app.register(module_name, {
+                        type: "frontend",
+                        extensions: [...extensions],
+                        client: init.client,
+                        async onLoad(file) {
+                            if (!build_ssr)
                                 return "";
                             // production: just compile to JS, don't bundle yet
                             if (compile_server !== undefined) {
                                 return await compile_server(await file.text(), file);
                             }
                             return await file.text();
-                        });
+                        },
                     });
                     // build
                     if (init.root !== undefined && compile_server !== undefined) {
@@ -164,7 +166,6 @@ export default function frontend_module(init) {
                     // publish
                     if (compile_client !== undefined) {
                         if (init.client) {
-                            app.frontends.set(module_name, [...extensions]);
                             conditions.forEach(c => app.conditions.add(c));
                         }
                         app.plugin("client", {
@@ -198,6 +199,7 @@ export default function frontend_module(init) {
                                 }
                                 const views_filter = new RegExp(`^${module_name}:views`);
                                 const views_base = app.root.join(location.views);
+                                const pages_base = app.root.join(location.routes);
                                 build.onResolve({ filter: views_filter }, ({ path }) => {
                                     return { namespace: `${module_name}`, path };
                                 });
@@ -206,17 +208,26 @@ export default function frontend_module(init) {
                                         recursive: true,
                                         filter: c => extensions.includes(c.fullExtension),
                                     });
+                                    const pages = await pages_base.files({
+                                        recursive: true,
+                                        filter: c => extensions.includes(c.fullExtension),
+                                    });
                                     let contents = "";
                                     for (const view of views) {
                                         const { path } = view.debase(views_base, "/");
                                         contents += `export { default as ${await normalize(path)} }
                       from "view:${path}";\n`;
+                                    }
+                                    for (const page of pages) {
+                                        const { path } = page.debase(pages_base, "/");
+                                        contents += `export { default as ${await normalize(`$page/${path}`)} }
+                      from "page:${path}";\n`;
                                     }
                                     return {
                                         contents,
                                         resolveDir: app.root.path,
-                                        watchDirs: [views_base.path],
-                                        watchFiles: views.map(view => view.path),
+                                        watchDirs: [views_base.path, pages_base.path],
+                                        watchFiles: views.map(view => view.path).concat(pages.map(page => page.path)),
                                     };
                                 });
                                 const filter = new RegExp(`(${extensions.map(e => e.replace(".", "\\.")).join("|")})$`);

package/lib/private/location.d.ts

@@ -3,7 +3,7 @@ declare const _default: {
     readonly client: "client";
     readonly config: "config";
     readonly error_html: "error.html";
-    readonly pages: "pages";
+    readonly templates: "templates";
     readonly routes: "routes";
     readonly static: "static";
     readonly stores: "stores";

package/lib/private/location.js

@@ -7,8 +7,8 @@ export default {
     config: "config",
     // error rendering template
     error_html: "error.html",
-    // HTML pages
-    pages: "pages",
+    // HTML templates
+    templates: "templates",
     // hierarchical routes
     routes: "routes",
     // static assets

package/lib/private/request/RequestBody.d.ts

@@ -1,13 +1,13 @@
 import http from "@rcompat/http";
 import type { Dict, JSONValue } from "@rcompat/type";
-import type { Parsed } from "pema";
+import type { AsyncType, Parsed } from "pema";
 type Form = Dict<string>;
 type Files = Dict<File>;
 type MIMES = typeof http.MIME;
 type MIME = MIMES[keyof MIMES];
 type BodyOptions = {
     contentType: MIME;
-    schema: Parsed<unknown>;
+    schema: Parsed<unknown> | AsyncType;
 };
 declare const patched: unique symbol;
 export default class RequestBody {

package/lib/private/request/RequestBody.js

@@ -26,7 +26,7 @@ export default class RequestBody {
         this.#parse(http.MIME.APPLICATION_JSON);
         const raw = await this.#request.json();
         return this.#options?.contentType === http.MIME.APPLICATION_JSON
-            ? this.#options.schema.parse(raw)
+            ? await this.#options.schema.parse(raw)
             : raw;
     }
     async form() {
@@ -37,7 +37,7 @@ export default class RequestBody {
         }
         const raw = form;
         return this.#options?.contentType === http.MIME.APPLICATION_X_WWW_FORM_URLENCODED
-            ? this.#options.schema.parse(raw)
+            ? await this.#options.schema.parse(raw)
             : raw;
     }
     async multipart() {
@@ -54,21 +54,21 @@ export default class RequestBody {
         }
         const raw = { form, files };
         return this.#options?.contentType === http.MIME.MULTIPART_FORM_DATA
-            ? this.#options.schema.parse(raw)
+            ? await this.#options.schema.parse(raw)
             : raw;
     }
     async text() {
         this.#parse(http.MIME.TEXT_PLAIN);
         const raw = await this.#request.text();
         return this.#options?.contentType === http.MIME.TEXT_PLAIN
-            ? this.#options.schema.parse(raw)
+            ? await this.#options.schema.parse(raw)
             : raw;
     }
     async blob() {
         this.#parse(http.MIME.APPLICATION_OCTET_STREAM);
         const raw = await this.#request.blob();
         return this.#options?.contentType === http.MIME.APPLICATION_OCTET_STREAM
-            ? this.#options.schema.parse(raw)
+            ? await this.#options.schema.parse(raw)
             : raw;
     }
 }

package/lib/private/request/route.js

@@ -46,14 +46,17 @@ export default async function (app, partial_request) {
             app.log.trace `no route for pathname ${partial_request.url.pathname}`;
             return response_error()(app, {}, partial_request);
         }
-        const { errors, hooks = [], layouts, handler, is_head } = route;
+        const { errors, hooks = [], layouts, handler, is_head, path } = route;
         errorRoute = errors[0];
         const internal_hooks = app.route_hooks.map(wrap_hook);
         const route_hooks = hooks.map(wrap_hook);
         const last = async (req, _next) => result(req, await handler(req));
         const { request, response } = await run([...internal_hooks, ...route_hooks, last], route.request);
         const full = await respond(response)(app, {
-            layouts: await Promise.all(layouts.map(layout => layout(request))),
+            route: path,
+            layouts: await Promise.all(layouts.map(({ handler, path }) => Promise.resolve(handler(request)).then(response => typeof response === "function"
+                ? (app, transfer, request) => response(app, { ...transfer, route: path }, request)
+                : response))),
         }, request);
         return is_head
             ? new Response(null, { headers: full.headers, status: full.status })
@@ -70,7 +73,7 @@ export default async function (app, partial_request) {
         app.log.error(error);
         // the +error.js page itself could fail
         try {
-            return respond(await errorRoute(request))(app, {}, request);
+            return respond(await errorRoute.handler(request))(app, { route: errorRoute.path }, request);
         }
         catch {
             return response_error()(app, {}, request);

package/lib/private/request/router.d.ts

@@ -1,5 +1,5 @@
 import type { FileRef } from "@rcompat/fs";
 import FileRouter from "@rcompat/fs/FileRouter";
 export default _default;
-declare function _default(directory: FileRef, extensions: string[]): Promise<FileRouter>;
+declare function _default(directory: FileRef, extensions: string[], excluded_extensions?: string[]): Promise<FileRouter>;
 //# sourceMappingURL=router.d.ts.map

package/lib/private/request/router.js

@@ -3,8 +3,18 @@ import FileRouter from "@rcompat/fs/FileRouter";
 const re = /^[a-zA-Z0-9\-_+[\].]+$/;
 const specials = ["error", "hook", "layout"];
 const p = /^(?:[^[\]]+|\[(?:\.{3})?[a-zA-Z0-9_]+\]|\[\[(?:\.{3})?[a-zA-Z0-9_]+\]\])$/;
-export default async (directory, extensions) => {
-    const router = await FileRouter.load({
+export default async (directory, extensions, excluded_extensions = []) => {
+    const escaped = extensions.map(e => e.replace(".", "\\."));
+    const filter = new RegExp(`^.*(${escaped.join("|")})$`, "u");
+    const route_files = (await directory.files({ filter, recursive: true }))
+        .filter(file => !excluded_extensions.some(ext => file.path.endsWith(ext)))
+        .map(file => {
+        const extension = extensions
+            .toSorted((a, b) => b.length - a.length)
+            .find(extension => file.path.endsWith(extension));
+        return file.debase(directory).path.slice(1, -extension.length);
+    });
+    const router = FileRouter.init({
         directory: directory.toString(),
         extensions,
         specials: {
@@ -12,12 +22,13 @@ export default async (directory, extensions) => {
             hook: { recursive: true },
             layout: { recursive: true },
         },
-    });
+    }, route_files);
     router.all().map(route => {
         const { path, segment } = route;
         if (!re.test(segment))
             throw E.route_invalid_characters(path, re);
-        if (segment.startsWith("+") && !specials.includes(segment.slice(1))) {
+        const special = segment.slice(1).split(".")[0];
+        if (segment.startsWith("+") && !specials.includes(special)) {
             throw E.route_invalid_special_file(path);
         }
         if (!p.test(segment))

package/lib/private/response/ResponseFunction.d.ts

@@ -2,6 +2,9 @@ import type View from "#client/View";
 import type RequestFacade from "#request/RequestFacade";
 import type ServeApp from "#serve/App";
 import type { Dict, MaybePromise } from "@rcompat/type";
-type ResponseFunction = (app: ServeApp, transfer: Dict, request: RequestFacade) => MaybePromise<View | null | Response | undefined>;
+type ResponseFunction<Props = unknown> = {
+    (app: ServeApp, transfer: Dict, request: RequestFacade): MaybePromise<View | null | Response | undefined>;
+    readonly _props?: Props;
+};
 export { ResponseFunction as default };
 //# sourceMappingURL=ResponseFunction.d.ts.map

package/lib/private/response/ResponseLike.d.ts

@@ -1,6 +1,6 @@
 import type ResponseFunction from "#response/ResponseFunction";
 import type Streamable from "@rcompat/fs/Streamable";
 import type { Dict } from "@rcompat/type";
-type ResponseLike = string | Dict | Dict[] | URL | Blob | ReadableStream | Streamable | Response | ResponseFunction | null;
+type ResponseLike = string | Dict | Dict[] | URL | Blob | ReadableStream | Streamable | Response | ResponseFunction<any> | null;
 export { ResponseLike as default };
 //# sourceMappingURL=ResponseLike.d.ts.map

package/lib/private/response/error.d.ts

@@ -2,7 +2,7 @@ import type ResponseFunction from "#response/ResponseFunction";
 import type { ValidStatus } from "@rcompat/http";
 type Options = {
     body?: string;
-    page?: string;
+    template?: string;
     status?: ValidStatus;
 };
 /**
@@ -10,7 +10,7 @@ type Options = {
  *
  * @param options.body HTML `%body%` replacement (default: `"Not Found"`).
  * @param options.status Request status (default: `404 Not Found`).
- * @param options.page HTML page to use (default: `error.html`).
+ * @param options.template HTML template to use (default: `error.html`).
  * @return Response function.
  */
 export default function error(options?: Options): ResponseFunction;

package/lib/private/response/error.js

@@ -8,14 +8,14 @@ const sse_reload = `<script>
  *
  * @param options.body HTML `%body%` replacement (default: `"Not Found"`).
  * @param options.status Request status (default: `404 Not Found`).
- * @param options.page HTML page to use (default: `error.html`).
+ * @param options.template HTML template to use (default: `error.html`).
  * @return Response function.
  */
 export default function error(options) {
     return app => app.view({
         body: options?.body ?? "Not Found",
         head: app.mode === "development" ? sse_reload : undefined,
-        page: options?.page ?? location.error_html,
+        template: options?.template ?? location.error_html,
         status: options?.status ?? http.Status.NOT_FOUND,
     });
 }

package/lib/private/response/page.d.ts

@@ -0,0 +1,6 @@
+import type ViewOptions from "#client/ViewOptions";
+import type ResponseFunction from "#response/ResponseFunction";
+import type { Dict } from "@rcompat/type";
+declare function page<Props extends Dict>(props?: Props, options?: ViewOptions): ResponseFunction<Props>;
+export default page;
+//# sourceMappingURL=page.d.ts.map

package/lib/private/response/page.js

@@ -0,0 +1,12 @@
+import E from "#errors";
+import response_view from "#response/view";
+import is from "@rcompat/is";
+function page(props, options) {
+    return (app, transfer, request) => {
+        if (!is.string(transfer.route))
+            throw E.response_page_context_missing();
+        return response_view(app.page(transfer.route), props, options)(app, transfer, request);
+    };
+}
+export default page;
+//# sourceMappingURL=page.js.map

package/lib/private/response/sse.d.ts

@@ -1,9 +1,8 @@
-type Body = {
-    close?(): undefined;
-    open(events: {
-        send(name: string, data: unknown): undefined;
-    }): undefined;
+type Source = {
+    send(name: string, data: unknown): void;
 };
+type Cleanup = void | (() => void);
+type Body = (source: Source) => Cleanup;
 /**
  * Open a server-sent event stream
  * @param body implementation body

package/lib/private/response/sse.js

@@ -1,20 +1,23 @@
 import response from "#response";
 import http from "@rcompat/http";
 const encode = (input) => new TextEncoder().encode(input);
-const handle = (body) => new ReadableStream({
-    cancel() {
-        body.close?.();
-    },
-    start(controller) {
-        body.open({
-            send(name, data) {
-                const event = data === undefined ? "" : `event: ${name}\n`;
-                const _data = JSON.stringify(data === undefined ? name : data);
-                controller.enqueue(encode(`${event}data:${_data}\n\n`));
-            },
-        });
-    },
-});
+const handle = (body) => {
+    let cleanup;
+    return new ReadableStream({
+        cancel() {
+            cleanup?.();
+        },
+        start(controller) {
+            cleanup = body({
+                send(name, data) {
+                    const event = data === undefined ? "" : `event: ${name}\n`;
+                    const _data = JSON.stringify(data === undefined ? name : data);
+                    controller.enqueue(encode(`${event}data:${_data}\n\n`));
+                },
+            });
+        },
+    });
+};
 /**
  * Open a server-sent event stream
  * @param body implementation body

package/lib/private/response/view.d.ts

@@ -1,9 +1,9 @@
 import type ViewOptions from "#client/ViewOptions";
 import type ResponseFunction from "#response/ResponseFunction";
 import type { Dict } from "@rcompat/type";
-declare function view(component: abstract new (...args: any[]) => any, props?: Dict, options?: ViewOptions): ResponseFunction;
-declare function view<Props>(component: (props: Props) => any, props: Props, options?: ViewOptions): ResponseFunction;
-declare function view(component: () => any, props?: Dict, options?: ViewOptions): ResponseFunction;
-declare function view(name: string, props?: Dict, options?: ViewOptions): ResponseFunction;
+declare function view(component: abstract new (...args: any[]) => any, props?: Dict, options?: ViewOptions): ResponseFunction<Dict>;
+declare function view<Props>(component: unknown, props: Props, options?: ViewOptions): ResponseFunction<Props>;
+declare function view(component: unknown, props?: Dict, options?: ViewOptions): ResponseFunction<Dict>;
+declare function view<Props extends Dict>(name: string, props?: Props, options?: ViewOptions): ResponseFunction<Props>;
 export default view;
 //# sourceMappingURL=view.d.ts.map

package/lib/private/route/NarrowedRequest.d.ts

@@ -3,7 +3,9 @@ import type RequestBody from "#request/RequestBody";
 import type RequestFacade from "#request/RequestFacade";
 import type RouteOptions from "#route/Options";
 import type { Unpack } from "@rcompat/type";
-import type { Parsed } from "pema";
+type InferSchema<S> = S extends {
+    infer: infer I;
+} ? Awaited<I> : never;
 type ContentTypeMethod = {
     "application/json": "json";
     "text/plain": "text";
@@ -13,13 +15,13 @@ type ContentTypeMethod = {
 };
 type NarrowedBody<O extends RouteOptions, B extends RequestBody> = O extends {
     contentType: infer CT extends keyof ContentTypeMethod;
-    body: Parsed<infer T>;
+    body: infer S;
 } ? Omit<B, ContentTypeMethod[CT]> & {
-    [K in ContentTypeMethod[CT]]: () => Promise<Unpack<T>>;
+    [K in ContentTypeMethod[CT]]: () => Promise<Unpack<InferSchema<S>>>;
 } : B;
 type NarrowedPath<O extends RouteOptions> = O extends {
-    path: Parsed<infer T>;
-} ? RequestBag<Unpack<T>> : RequestBag;
+    path: infer S;
+} ? RequestBag<Unpack<InferSchema<S>>> : RequestBag;
 type NarrowedRequest<O extends RouteOptions> = Omit<RequestFacade, "body" | "path"> & {
     body: NarrowedBody<O, RequestBody>;
     path: NarrowedPath<O>;