@primate/core 0.7.3 → 0.7.4

package/lib/private/Flags.d.ts

@@ -2,12 +2,12 @@ declare const _default: import("pema").ObjectType<import("pema").NormalizeSchema
     readonly mode: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"production">, import("pema").LiteralType<"development">, import("pema").LiteralType<"testing">]>, "development" | "production" | "testing">;
     readonly target: import("pema").DefaultType<import("pema").StringType, "web">;
     readonly outdir: import("pema").DefaultType<import("pema").StringType, "build">;
-    readonly log: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"error">, import("pema").LiteralType<"warn">, import("pema").LiteralType<"info">, import("pema").LiteralType<"trace">]>, "trace" | "info" | "error" | "warn">;
+    readonly log: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"error">, import("pema").LiteralType<"warn">, import("pema").LiteralType<"info">, import("pema").LiteralType<"trace">]>, "info" | "error" | "trace" | "warn">;
 }>, {
     mode: "development" | "production" | "testing";
     target: string;
     outdir: string;
-    log: "trace" | "info" | "error" | "warn";
+    log: "info" | "error" | "trace" | "warn";
 }>;
 export default _default;
 //# sourceMappingURL=Flags.d.ts.map

package/lib/private/build/client/index.js

@@ -1,6 +1,8 @@
 import plugin_alias from "#build/client/plugin/alias";
 import plugin_entrypoint from "#build/client/plugin/entrypoint";
 import plugin_frontend from "#build/client/plugin/frontend";
+import plugin_route_module from "#build/client/plugin/route-module";
+import plugin_route_view from "#build/client/plugin/route-view";
 import plugin_routes from "#build/client/plugin/routes";
 import plugin_server_stamp from "#build/client/plugin/server-stamp";
 import plugin_view from "#build/client/plugin/view";
@@ -53,6 +55,8 @@ export default async function build_client(app) {
     app.plugin("client", plugin_alias(app));
     app.plugin("client", plugin_view(app));
     app.plugin("client", plugin_app_request(app));
+    app.plugin("client", plugin_route_view(app));
+    app.plugin("client", plugin_route_module(app));
     app.plugin("client", plugin_routes(app));
     app.plugin("client", plugin_server_stamp(app));
     app.plugin("client", plugin_entrypoint(app));

package/lib/private/build/client/plugin/route-module.d.ts

@@ -0,0 +1,4 @@
+import type BuildApp from "#build/App";
+import type { Plugin } from "esbuild";
+export default function plugin_client_route_module(app: BuildApp): Plugin;
+//# sourceMappingURL=route-module.d.ts.map

package/lib/private/build/client/plugin/route-module.js

@@ -0,0 +1,32 @@
+import fs from "@rcompat/fs";
+export default function plugin_client_route_module(app) {
+    return {
+        name: "primate/client/route-module",
+        setup(build) {
+            build.onResolve({ filter: /^app:route\// }, args => {
+                const rel = args.path.slice("app:route/".length);
+                return { path: rel, namespace: "primate-route" };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-route" }, async (args) => {
+                const base = app.path.routes.join(args.path);
+                for (const ext of app.extensions) {
+                    const candidate = fs.ref(base.path + ext);
+                    if (await candidate.exists()) {
+                        const binder = app.binder(candidate);
+                        const contents = binder
+                            ? await binder(candidate, { build: { id: app.id }, context: "routes" })
+                            : await candidate.text();
+                        return {
+                            contents,
+                            loader: ext === ".ts" ? "ts" : "js",
+                            resolveDir: candidate.directory.path,
+                            watchFiles: [candidate.path],
+                        };
+                    }
+                }
+                return null;
+            });
+        },
+    };
+}
+//# sourceMappingURL=route-module.js.map

package/lib/private/build/client/plugin/route-view.d.ts

@@ -0,0 +1,4 @@
+import type BuildApp from "#build/App";
+import type { Plugin } from "esbuild";
+export default function plugin_client_route_view(app: BuildApp): Plugin;
+//# sourceMappingURL=route-view.d.ts.map

package/lib/private/build/client/plugin/route-view.js

@@ -0,0 +1,37 @@
+import fs from "@rcompat/fs";
+export default function plugin_client_route_view(app) {
+    return {
+        name: "primate/client/route-view",
+        setup(build) {
+            build.onResolve({ filter: /.*/ }, async (args) => {
+                if (args.namespace !== "primate-route")
+                    return null;
+                if (args.pluginData === "primate-view-inner")
+                    return null;
+                const result = await build.resolve(args.path, {
+                    resolveDir: args.resolveDir,
+                    kind: args.kind,
+                    pluginData: "primate-view-inner",
+                });
+                if (result.errors.length > 0 || !result.path)
+                    return null;
+                const resolved = fs.ref(result.path);
+                if (!resolved.path.startsWith(app.path.views.path + "/"))
+                    return null;
+                return {
+                    path: resolved.path,
+                    namespace: "primate-client-route-view",
+                };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-client-route-view" }, args => {
+                const rel = fs.ref(args.path).debase(app.path.views).path.replace(/^[\\/]/, "");
+                return {
+                    contents: `export default ${JSON.stringify(rel)};`,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=route-view.js.map

package/lib/private/build/client/plugin/routes.js

@@ -1,29 +1,9 @@
 import intercept from "#build/shared/intercept";
-import E from "#errors";
 import fs from "@rcompat/fs";
-const body_serializer = {
-    "application/json": "JSON.stringify(body)",
-    "application/x-www-form-urlencoded": "new URLSearchParams(body).toString()",
-    "multipart/form-data": "body",
-    "text/plain": "body",
-    "application/octet-stream": "body",
-};
 export default function plugin_client_routes(app) {
-    let manifest;
-    async function get_manifest() {
-        if (manifest === undefined) {
-            manifest = await app.path.build
-                .join("route.manifest.json")
-                .json();
-        }
-        return manifest;
-    }
     return {
         name: "primate/client/routes",
         setup(build) {
-            build.onStart(() => {
-                manifest = undefined;
-            });
             build.onResolve({ filter: /.*/ }, async (args) => {
                 if (args.pluginData === "primate-client-route-inner")
                     return null;
@@ -40,36 +20,24 @@ export default function plugin_client_routes(app) {
                 if (!resolved.path.startsWith(app.path.routes.path + "/"))
                     return null;
                 const rel = app.basename(resolved, app.path.routes);
-                return { path: rel, namespace: "primate-client-route" };
+                return {
+                    namespace: "primate-client-route",
+                    path: resolved.path,
+                    pluginData: { rel },
+                };
             });
             build.onLoad({ filter: /.*/, namespace: "primate-client-route" }, async (args) => {
-                const manifest = await get_manifest();
-                const methods_def = manifest[args.path];
-                if (!methods_def)
-                    throw new Error(`no manifest entry for ${args.path}`);
-                if (args.path.includes("["))
-                    throw E.build_no_path_schema(args.path);
-                const methods = Object.entries(methods_def).map(([method, { contentType }]) => {
-                    const arg = contentType ? "{ body }" : "";
-                    const headers = contentType && contentType !== "multipart/form-data"
-                        ? `{ "Content-Type": "${contentType}" }`
-                        : "{}";
-                    const body_str = contentType !== undefined
-                        ? (body_serializer[contentType] ?? "body")
-                        : "undefined";
-                    const method_fn = `async (${arg}) => fetch("/${args.path}", {
-            method: "${method.toUpperCase()}",
-            headers: ${headers},
-            ${contentType ? `body: ${body_str},` : ""}
-          })`;
-                    return `
-            ${method}: Object.assign(${method_fn}, {
-              contentType: ${contentType ? `"${contentType}"` : "undefined"},
-            }),
-          `;
-                }).join("\n");
-                const contents = `export default { ${methods} };`;
-                return { contents, loader: "js", resolveDir: app.root.path };
+                const file = fs.ref(args.path);
+                const rel = args.pluginData.rel;
+                return {
+                    contents: `
+            import _mod from "app:route/${rel}";
+            export default _mod.connect(${JSON.stringify(`/${rel}`)});
+          `,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                    watchFiles: [file.path],
+                };
             });
         },
     };

package/lib/private/build/hook.js

@@ -1,5 +1,4 @@
 import build_client from "#build/client/index";
-import build_preclient from "#build/preclient/index";
 import build_server from "#build/server/index";
 import E from "#errors";
 import location from "#location";
@@ -33,8 +32,6 @@ async function pre(app) {
     app.session_active = await session_ts.exists() || await session_js.exists();
 }
 async function post(app) {
-    app.log.trace `building preclient`;
-    await build_preclient(app);
     app.log.trace `building client`;
     await build_client(app);
     app.log.trace `building server`;

package/lib/private/build/server/plugin/route-client.js

@@ -1,46 +1,5 @@
 import intercept from "#build/shared/intercept";
 import fs from "@rcompat/fs";
-const fake_body = {
-    "application/json": `{
-    json: () => body,
-    text: () => JSON.stringify(body),
-    form: () => { throw new Error("cannot parse JSON as form") },
-    multipart: () => { throw new Error("cannot parse JSON as multipart") },
-    blob: () => new Blob([JSON.stringify(body)]),
-  }`,
-    "text/plain": `{
-    json: () => JSON.parse(body),
-    text: () => body,
-    form: () => { throw new Error("cannot parse text as form") },
-    multipart: () => { throw new Error("cannot parse text as multipart") },
-    blob: () => new Blob([body]),
-  }`,
-    "application/x-www-form-urlencoded": `{
-    json: () => { throw new Error("cannot parse form as JSON") },
-    text: () => new URLSearchParams(body).toString(),
-    //form: () => body,
-    form: () => Object.fromEntries(new URLSearchParams(body)),
-    multipart: () => ({ form: body, files: [] }),
-    blob: () => new Blob([new URLSearchParams(body).toString()]),
-  }`,
-    "multipart/form-data": `{
-    json: () => { throw new Error("cannot parse multipart as JSON") },
-    text: () => body,
-    form: () => body.form,
-    multipart: () => ({
-      form: Object.fromEntries([...body.entries()].filter(([, v]) => !(v instanceof File))),
-      files: Object.fromEntries([...body.entries()].filter(([, v]) => v instanceof File)),
-    }),
-    blob: () => new Blob([]),
-  }`,
-    "application/octet-stream": `{
-    json: () => { throw new Error("cannot parse binary as JSON") },
-    text: () => body.text(),
-    form: () => { throw new Error("cannot parse binary as form") },
-    multipart: () => { throw new Error("cannot parse binary as multipart") },
-    blob: () => body,
-  }`,
-};
 export default function plugin_server_route_client(app) {
     return {
         name: "primate/server/route-client",
@@ -65,45 +24,129 @@ export default function plugin_server_route_client(app) {
                 if (!args.resolveDir.startsWith(app.path.views.path))
                     return null;
                 const rel = app.basename(resolved, app.path.routes);
-                return { path: rel, namespace: "primate-server-route-client" };
+                return {
+                    path: rel,
+                    namespace: "primate-server-route-client",
+                };
             });
             build.onLoad({ filter: /.*/, namespace: "primate-server-route-client" }, async (args) => {
-                const manifest = await app.path.build
-                    .join("route.manifest.json")
-                    .json();
-                const methods_def = manifest[args.path];
-                if (!methods_def)
-                    throw new Error(`no manifest entry for ${args.path}`);
-                const methods = Object.entries(methods_def).map(([method, { contentType }]) => {
-                    const arg = contentType ? "{ body }" : "";
-                    const fake = contentType
-                        ? `{ body: ${fake_body[contentType] ?? fake_body["application/json"]} }`
-                        : "{}";
-                    return `
-            ${method}: async (${arg}) => {
-              const { handler } = mod.${method};
-              const result = await handler(${fake});
-              if (result instanceof Blob) {
-                return new Response(result, {
-                  headers: { "Content-Type": result.type || "application/octet-stream" },
-                });
-              }
-              if (typeof result === "string") {
-                return new Response(result, {
-                  headers: { "Content-Type": "text/plain" },
-                });
-              }
-              return new Response(JSON.stringify(result), {
-                headers: { "Content-Type": "application/json" },
-              });
-            },
-`;
-                }).join("\n");
                 const contents = `
           import mod from "app:route/${args.path}";
-          export default { ${methods} };
+
+          function fake_body(contentType, body) {
+            switch (contentType) {
+              case "application/json":
+                return {
+                  json: () => body,
+                  text: () => JSON.stringify(body),
+                  form: () => { throw new Error("cannot parse JSON as form"); },
+                  multipart: () => { throw new Error("cannot parse JSON as multipart"); },
+                  blob: () => new Blob([JSON.stringify(body)]),
+                };
+
+              case "text/plain":
+                return {
+                  json: () => JSON.parse(body),
+                  text: () => body,
+                  form: () => { throw new Error("cannot parse text as form"); },
+                  multipart: () => { throw new Error("cannot parse text as multipart"); },
+                  blob: () => new Blob([body]),
+                };
+
+              case "application/x-www-form-urlencoded":
+                return {
+                  json: () => { throw new Error("cannot parse form as JSON"); },
+                  text: () => new URLSearchParams(body).toString(),
+                  form: () => Object.fromEntries(new URLSearchParams(body)),
+                  multipart: () => ({ form: body, files: [] }),
+                  blob: () => new Blob([new URLSearchParams(body).toString()]),
+                };
+
+              case "multipart/form-data":
+                return {
+                  json: () => { throw new Error("cannot parse multipart as JSON"); },
+                  text: () => body,
+                  form: () => body.form,
+                  multipart: () => ({
+                    form: Object.fromEntries([...body.entries()].filter(([, v]) => !(v instanceof File))),
+                    files: Object.fromEntries([...body.entries()].filter(([, v]) => v instanceof File)),
+                  }),
+                  blob: () => new Blob([]),
+                };
+
+              case "application/octet-stream":
+                return {
+                  json: () => { throw new Error("cannot parse binary as JSON"); },
+                  text: () => body.text(),
+                  form: () => { throw new Error("cannot parse binary as form"); },
+                  multipart: () => { throw new Error("cannot parse binary as multipart"); },
+                  blob: () => body,
+                };
+
+              default:
+                return {
+                  json: () => body,
+                  text: () => JSON.stringify(body),
+                  form: () => { throw new Error("cannot parse body as form"); },
+                  multipart: () => { throw new Error("cannot parse body as multipart"); },
+                  blob: () => new Blob([JSON.stringify(body)]),
+                };
+            }
+          }
+
+          function fake_request(contentType, body) {
+            return contentType === undefined
+              ? {}
+              : { body: fake_body(contentType, body) };
+          }
+
+          function to_response(result) {
+            if (result instanceof Response) {
+              return result;
+            }
+
+            if (result instanceof Blob) {
+              return new Response(result, {
+                headers: { "Content-Type": result.type || "application/octet-stream" },
+              });
+            }
+
+            if (typeof result === "string") {
+              return new Response(result, {
+                headers: { "Content-Type": "text/plain" },
+              });
+            }
+
+            if (result === null || result === undefined) {
+              return new Response(null, { status: 204 });
+            }
+
+            return new Response(JSON.stringify(result), {
+              headers: { "Content-Type": "application/json" },
+            });
+          }
+
+          export default Object.fromEntries(
+            Object.entries(mod).map(([method, route]) => {
+              const contentType = route.options?.contentType;
+
+              const client_method = async ({ body } = {}) => {
+                const result = await route.handler(fake_request(contentType, body));
+                return to_response(result);
+              };
+
+              return [
+                method,
+                Object.assign(client_method, { contentType }),
+              ];
+            }),
+          );
         `;
-                return { contents, loader: "js", resolveDir: app.root.path };
+                return {
+                    contents,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                };
             });
         },
     };

package/lib/private/frontend.js

@@ -219,6 +219,8 @@ export default function frontend_module(init) {
                                 });
                                 const filter = new RegExp(`(${extensions.map(e => e.replace(".", "\\.")).join("|")})$`);
                                 build.onLoad({ filter }, async (args) => {
+                                    if (args.namespace !== "file")
+                                        return null;
                                     const file = fs.ref(args.path);
                                     // compile file to JavaScript and potentially CSS
                                     const compiled = await compile_client(await file.text(), file, false);

package/lib/private/logger.d.ts

@@ -1,5 +1,5 @@
 import type { LogHook } from "#module/Setup";
-declare const Schema: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"error">, import("pema").LiteralType<"warn">, import("pema").LiteralType<"info">, import("pema").LiteralType<"trace">]>, "trace" | "info" | "error" | "warn">;
+declare const Schema: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"error">, import("pema").LiteralType<"warn">, import("pema").LiteralType<"info">, import("pema").LiteralType<"trace">]>, "info" | "error" | "trace" | "warn">;
 export { Schema };
 declare const levels: {
     readonly error: 0;

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

@@ -0,0 +1,13 @@
+declare const _default: {
+    binary: () => never;
+    error: () => never;
+    json: () => never;
+    redirect: () => never;
+    sse: () => never;
+    text: () => never;
+    view: () => never;
+    ws: () => never;
+    null: () => never;
+};
+export default _default;
+//# sourceMappingURL=response.client.d.ts.map

package/lib/private/response.client.js

@@ -0,0 +1,15 @@
+function server_only(name) {
+    throw new Error(`response.${name}() is server-only`);
+}
+export default {
+    binary: () => server_only("binary"),
+    error: () => server_only("error"),
+    json: () => server_only("json"),
+    redirect: () => server_only("redirect"),
+    sse: () => server_only("sse"),
+    text: () => server_only("text"),
+    view: () => server_only("view"),
+    ws: () => server_only("ws"),
+    null: () => server_only("null"),
+};
+//# sourceMappingURL=response.client.js.map

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

@@ -27,7 +27,14 @@ type WithResult<O extends RouteOptions> = {
 type RouteHandlers = {
     [key: string]: RouteHandler | WithResult<RouteOptions>;
 };
-declare function route<R extends RouteHandlers>(handlers: R): ClientRoute<R>;
+declare function route<R extends RouteHandlers>(handlers: R): {
+    _handlers: {
+        [k: string]: {
+            contentType: ("application/x-7z-compressed" | "application/octet-stream" | "application/x-bzip2" | "application/gzip" | "application/json" | "application/ld+json" | "application/pdf" | "application/x-rar-compressed" | "application/rss+xml" | "application/x-tar" | "application/wasm" | "application/manifest+json" | "application/xml" | "application/yaml" | "application/zip" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "font/otf" | "font/ttf" | "font/woff" | "font/woff2" | "image/apng" | "image/avif" | "image/bmp" | "image/gif" | "image/x-icon" | "image/jpeg" | "image/png" | "image/svg+xml" | "image/tiff" | "image/webp" | "text/css" | "text/csv" | "text/html" | "text/javascript" | "text/markdown" | "text/rtf" | "text/plain" | "text/tab-separated-values" | "text/vtt" | "video/quicktime" | "video/mp4" | "video/ogg" | "video/mp2t" | "video/webm" | "application/x-www-form-urlencoded" | "multipart/form-data" | "text/event-stream") | undefined;
+        };
+    };
+    connect(path: string): ClientRoute<R>;
+};
 declare namespace route {
     var _a: <O extends RouteOptions>(options: O, handler: RouteHandler<O>) => WithResult<O>;
     export { _a as with };

package/lib/private/route.client.js

@@ -1,5 +1,48 @@
+function is_with(value) {
+    return typeof value === "object" &&
+        value !== null &&
+        "handler" in value &&
+        "options" in value;
+}
+function serialize_body(contentType, body) {
+    if (body === undefined)
+        return undefined;
+    if (contentType === "application/json") {
+        return JSON.stringify(body);
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+        return body instanceof URLSearchParams
+            ? body
+            : new URLSearchParams(body);
+    }
+    return body;
+}
+function headers(contentType) {
+    if (contentType === undefined)
+        return {};
+    if (contentType === "multipart/form-data")
+        return {};
+    return { "Content-Type": contentType };
+}
 function route(handlers) {
-    return {};
+    return {
+        _handlers: Object.fromEntries(Object.entries(handlers).map(([method, value]) => {
+            const options = is_with(value) ? value.options : {};
+            return [method, { contentType: options.contentType }];
+        })),
+        connect(path) {
+            return Object.fromEntries(Object.entries(this._handlers).map(([method, { contentType }]) => {
+                const fn = async (args = {}) => {
+                    return fetch(path, {
+                        method: method.toUpperCase(),
+                        headers: headers(contentType),
+                        body: serialize_body(contentType, args.body),
+                    });
+                };
+                return [method, Object.assign(fn, { contentType })];
+            }));
+        },
+    };
 }
 route.with = function (options, handler) {
     return { handler, options };

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

@@ -0,0 +1,11 @@
+declare function store(): {
+    create: () => Promise<undefined>;
+    drop: () => Promise<undefined>;
+    find: () => Promise<never[]>;
+    get: () => Promise<undefined>;
+    insert: () => Promise<undefined>;
+    update: () => Promise<number>;
+    delete: () => Promise<number>;
+};
+export default store;
+//# sourceMappingURL=store.client.d.ts.map

package/lib/private/store.client.js

@@ -0,0 +1,18 @@
+function method() {
+    return async () => {
+        return undefined;
+    };
+}
+function store() {
+    return {
+        create: method(),
+        drop: method(),
+        find: async () => [],
+        get: method(),
+        insert: method(),
+        update: async () => 0,
+        delete: async () => 0,
+    };
+}
+export default store;
+//# sourceMappingURL=store.client.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/core",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "The universal web framework",
   "homepage": "https://primate.run",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -60,6 +60,16 @@
       "browser": "./lib/public/route.client.js",
       "default": "./lib/public/route.js"
     },
+    "./response": {
+      "@primate/source": "./src/public/response.ts",
+      "browser": "./lib/private/response.client.js",
+      "default": "./lib/public/response.js"
+    },
+    "./store": {
+      "@primate/source": "./src/public/store.ts",
+      "browser": "./lib/private/store.client.js",
+      "default": "./lib/public/store.js"
+    },
     "./*": {
       "@primate/source": "./src/public/*.ts",
       "default": "./lib/public/*.js"

package/lib/private/build/preclient/index.d.ts

@@ -1,3 +0,0 @@
-import type BuildApp from "#build/App";
-export default function build_preclient(app: BuildApp): Promise<void>;
-//# sourceMappingURL=index.d.ts.map

package/lib/private/build/preclient/index.js

@@ -1,69 +0,0 @@
-import plugin_preclient_routes from "#build/preclient/plugin/routes";
-import plugin_assets from "#build/server/plugin/assets";
-import plugin_config from "#build/server/plugin/config";
-import plugin_frontend from "#build/server/plugin/frontend";
-import plugin_native_addons from "#build/server/plugin/native-addons";
-import plugin_node_imports from "#build/server/plugin/node-imports";
-import plugin_requires from "#build/server/plugin/requires";
-import plugin_roots from "#build/server/plugin/roots";
-import plugin_server_route from "#build/server/plugin/route";
-import plugin_stores from "#build/server/plugin/stores";
-import plugin_view from "#build/server/plugin/view";
-import plugin_views from "#build/server/plugin/views";
-import plugin_virtual_pages from "#build/server/plugin/virtual-pages";
-import plugin_wasm from "#build/server/plugin/wasm";
-import plugin_app_request from "#build/shared/plugin/app-request";
-import * as esbuild from "esbuild";
-export default async function build_preclient(app) {
-    const tsconfig_json = app.root.join("tsconfig.json");
-    const preclient = app.path.build.join("preclient.js");
-    const plugins = [
-        plugin_preclient_routes(app),
-        plugin_node_imports(app),
-        plugin_frontend(app),
-        plugin_view(app),
-        plugin_virtual_pages(app),
-        plugin_server_route(app),
-        plugin_roots(app),
-        plugin_views(app),
-        plugin_assets(app),
-        plugin_stores(app),
-        plugin_native_addons(app),
-        plugin_requires(app),
-        plugin_config(app),
-        plugin_wasm(app),
-        plugin_app_request(app),
-        ...app.plugins("server"),
-    ];
-    await esbuild.build({
-        entryPoints: ["app:preclient-routes"],
-        bundle: true,
-        write: true,
-        outfile: preclient.path,
-        format: "esm",
-        platform: "node",
-        packages: "external",
-        resolveExtensions: app.extensions,
-        absWorkingDir: app.root.path,
-        ...await tsconfig_json.exists() ? { tsconfig: tsconfig_json.path } : {},
-        conditions: ["node", "module", "import", "default"],
-        plugins,
-    });
-    const bundle = await preclient.import("default");
-    const manifest = {};
-    for (const [path, methods] of Object.entries(bundle)) {
-        manifest[path] = Object.fromEntries(Object.entries(methods).map(([method, { options }]) => [
-            method, {
-                ...(options?.contentType !== undefined && {
-                    contentType: options.contentType,
-                }),
-                ...(options?.body !== undefined && {
-                    body: options.body.toJSON(),
-                }),
-            },
-        ]));
-    }
-    await preclient.remove();
-    await app.path.build.join("route.manifest.json").writeJSON(manifest);
-}
-//# sourceMappingURL=index.js.map

package/lib/private/build/preclient/plugin/routes.d.ts

@@ -1,4 +0,0 @@
-import type BuildApp from "#build/App";
-import type { Plugin } from "esbuild";
-export default function plugin_preclient_routes(app: BuildApp): Plugin;
-//# sourceMappingURL=routes.d.ts.map

package/lib/private/build/preclient/plugin/routes.js

@@ -1,44 +0,0 @@
-function is_hook_file(p) {
-    const basename = p.split("/").at(-1) ?? p;
-    return basename === "+hook" || basename.startsWith("+hook.");
-}
-export default function plugin_preclient_routes(app) {
-    const extension_pattern = new RegExp(`(${app.extensions.map(e => e.replace(".", "\\.")).join("|")})$`);
-    function is_route_file(f) {
-        return !f.name.endsWith("~") &&
-            !f.name.startsWith(".") &&
-            !f.name.startsWith("-") &&
-            extension_pattern.test(f.path);
-    }
-    return {
-        name: "primate/preclient/routes",
-        setup(build) {
-            build.onResolve({ filter: /^app:preclient-routes$/ }, () => {
-                return { path: "preclient-routes", namespace: "primate-preclient-routes" };
-            });
-            build.onLoad({ filter: /.*/, namespace: "primate-preclient-routes" }, async () => {
-                const route_files = await app.path.routes.files({
-                    filter: is_route_file,
-                    recursive: true,
-                });
-                const filtered = route_files
-                    .filter(file => !is_hook_file(app.basename(file, app.path.routes)));
-                const contents = `
-                ${filtered.map((file, i) => {
-                    const path = app.basename(file, app.path.routes);
-                    return `import route${i} from "app:route/${path}";`;
-                }).join("\n")}
-
-                export default {
-                  ${filtered.map((file, i) => {
-                    const path = app.basename(file, app.path.routes);
-                    return `"${path}": route${i},`;
-                }).join("\n")}
-                };
-              `;
-                return { contents, loader: "js", resolveDir: app.root.path };
-            });
-        },
-    };
-}
-//# sourceMappingURL=routes.js.map