@primate/core 0.6.3 → 0.7.1

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

@@ -1,12 +1,14 @@
 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_routes from "#build/client/plugin/routes";
 import plugin_server_stamp from "#build/client/plugin/server-stamp";
 import plugin_view from "#build/client/plugin/view";
 import plugin_app_request from "#build/shared/plugin/app-request";
 import location from "#location";
+import { CodeError } from "@rcompat/error";
 import * as esbuild from "esbuild";
-const write_bootstrap = async (app, mode) => {
+const write_bootstrap = async (app) => {
     const build_start_script = `
     import serve from "primate/serve";
     import views from "app:views";
@@ -35,10 +37,11 @@ const write_bootstrap = async (app, mode) => {
       routes,
       views,
       pages,
-      mode: "${mode}",
       session: session_config,
       i18n: i18n_config,
+      mode: "${app.mode}",
       target: "${app.target.name}",
+      log: "${app.log.level}"
     });
 
     export default app;
@@ -50,6 +53,7 @@ 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_routes(app));
     app.plugin("client", plugin_server_stamp(app));
     app.plugin("client", plugin_entrypoint(app));
     const imports = await app.path.static.files({
@@ -72,6 +76,7 @@ export default async function build_client(app) {
         ...await tsconfig.exists() ? { tsconfig: tsconfig.path } : {},
         bundle: true,
         format: "esm",
+        logLevel: "silent",
     };
     const NO_HR = app.config("livereload.exclude") ?? [];
     const mode_options = app.mode === "development"
@@ -91,15 +96,24 @@ export default async function build_client(app) {
             splitting: true,
         };
     const options = { ...build_options, ...mode_options };
-    if (app.mode === "development") {
-        const context = await esbuild.context(options);
-        await context.watch();
-        await context.rebuild();
-        await context.serve(app.livereload);
+    try {
+        if (app.mode === "development") {
+            const context = await esbuild.context(options);
+            await context.watch();
+            await context.rebuild();
+            await context.serve(app.livereload);
+        }
+        else {
+            await esbuild.build(options);
+        }
     }
-    else {
-        await esbuild.build(options);
+    catch (cause) {
+        const original = cause?.errors?.[0]?.detail;
+        if (CodeError.is(original)) {
+            throw original;
+        }
+        throw cause;
     }
-    await write_bootstrap(app, app.mode);
+    await write_bootstrap(app);
 }
 //# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,77 @@
+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;
+                if (intercept(args, app.path.views))
+                    return null;
+                const result = await build.resolve(args.path, {
+                    resolveDir: args.resolveDir,
+                    kind: args.kind,
+                    pluginData: "primate-client-route-inner",
+                });
+                if (result.errors.length > 0 || !result.path)
+                    return null;
+                const resolved = fs.ref(result.path);
+                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" };
+            });
+            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 };
+            });
+        },
+    };
+}
+//# sourceMappingURL=routes.js.map

package/lib/private/build/hook.js

@@ -1,14 +1,15 @@
 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";
-import log from "#log";
 import $router from "#request/router";
 import s_layout_depth from "#symbol/layout-depth";
-import c from "@rcompat/cli/color";
-import fs from "@rcompat/fs";
-const core_pkg = await fs.project.package(import.meta.dirname);
-const { version } = await core_pkg.json();
+import assert from "@rcompat/assert";
+import cli from "@rcompat/cli";
+import runtime from "@rcompat/runtime";
+const package_json = await runtime.packageJSON(import.meta.dirname);
+const version = assert.string(package_json.version);
 async function pre(app) {
     const build_json = app.path.build.join("build.json");
     const build_path = app.path.build;
@@ -17,6 +18,8 @@ async function pre(app) {
     }
     await app.path.build.remove();
     await app.path.build.create();
+    // early stub in case of build errors
+    await app.path.build.join("build.json").writeJSON({});
     await app.runpath(location.client).create();
     const stamp = app.runpath("client", "server-stamp.js");
     await stamp.write("export default 0;\n");
@@ -30,7 +33,11 @@ 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`;
     await build_server(app);
     // write build.json with version and migration_version
     const migrations_dir = app.root.join("migrations");
@@ -39,11 +46,12 @@ async function post(app) {
         const files = await migrations_dir.files({ filter: /\d+-.*\.[jt]s$/ });
         migration_version = files.length === 0 ? 0 : Math.max(...files.map(f => parseInt(f.name.split("-")[0])));
     }
+    // overwrite stub
     await app.path.build.join("build.json").writeJSON({
         version,
         migration_version,
     });
-    log.print(`✓ build path  ${c.dim(app.path.build.path)}\n`);
+    app.log.print `✓ build path  ${cli.fg.dim(app.path.build.path)}\n`;
     app.cleanup();
     return app;
 }

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

@@ -1,5 +1,6 @@
+import BuildApp from "#build/App";
 import Flags from "#Flags";
 import type { FileRef } from "@rcompat/fs";
-declare const _default: (root: FileRef, input: typeof Flags.input) => Promise<true | undefined>;
-export default _default;
+declare function build(root: FileRef, input: typeof Flags.input): Promise<BuildApp>;
+export default build;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/build/index.js

@@ -1,10 +1,8 @@
 import { s_config } from "#app/Facade";
 import BuildApp from "#build/App";
-import bye from "#bye";
 import default_config from "#config/index";
 import E from "#errors";
 import Flags from "#Flags";
-import log from "#log";
 import dict from "@rcompat/dict";
 const no_config = (config) => config === undefined || dict.empty(config);
 async function find_config(root) {
@@ -31,17 +29,13 @@ async function get_config(root) {
     }
 }
 ;
-export default async (root, input) => {
-    try {
-        const flags = Flags.parse(input);
-        const config = await get_config(root);
-        const app = await new BuildApp(root, config, flags).init();
-        await app.buildInit();
-        return true;
-    }
-    catch (error) {
-        log.error(error);
-        bye();
-    }
-};
+async function build(root, input) {
+    const flags = Flags.parse(input);
+    const config = await get_config(root);
+    const app = await new BuildApp(root, config, flags).init();
+    await app.buildInit();
+    return app;
+}
+;
+export default build;
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,44 @@
+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

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

@@ -14,6 +14,7 @@ import plugin_virtual_pages from "#build/server/plugin/virtual-pages";
 import plugin_virtual_routes from "#build/server/plugin/virtual-routes";
 import plugin_wasm from "#build/server/plugin/wasm";
 import plugin_app_request from "#build/shared/plugin/app-request";
+import plugin_route_client from "#build/server/plugin/route-client";
 import runtime from "@rcompat/runtime";
 import * as esbuild from "esbuild";
 const externals = {
@@ -34,6 +35,7 @@ export default async function build_server(app) {
         app.plugin("server", plugin_live_reload(app));
     app.plugin("server", plugin_virtual_pages(app));
     app.plugin("server", plugin_virtual_routes(app));
+    app.plugin("server", plugin_route_client(app));
     app.plugin("server", plugin_route(app));
     app.plugin("server", plugin_roots(app));
     app.plugin("server", plugin_views(app));
@@ -45,7 +47,7 @@ export default async function build_server(app) {
     app.plugin("server", plugin_wasm(app));
     app.plugin("server", plugin_app_request(app));
     const runtime_name = runtime.name;
-    const tsconfig = app.root.join("tsconfig.json");
+    const tsconfig_json = app.root.join("tsconfig.json");
     const options = {
         entryPoints: [app.path.build.join("serve.js").path],
         outfile: app.path.build.join("server.js").path,
@@ -66,11 +68,12 @@ export default async function build_server(app) {
         nodePaths: [app.root.join("node_modules").path],
         resolveExtensions: app.extensions,
         absWorkingDir: app.root.path,
-        ...await tsconfig.exists() ? { tsconfig: tsconfig.path } : {},
+        ...await tsconfig_json.exists() ? { tsconfig: tsconfig_json.path } : {},
         conditions: [
-            ...conditions[runtime_name],
-            "module", "import", "runtime", "default",
-            ...app.conditions
+            ...conditions[runtime_name], // node | deno | bun
+            ...app.conditions, // set by modules
+            ...app.config("conditions"), // set by user,
+            "module", "import", "runtime", "default", // defaults
         ],
         plugins: app.plugins("server"),
         write: app.mode !== "development",

package/lib/private/build/server/plugin/assets.js

@@ -1,5 +1,5 @@
 import location from "#location";
-import { MIME } from "@rcompat/http";
+import http from "@rcompat/http";
 function bytes2base64(bytes) {
     const chunk_size = 0x8000;
     let result = "";
@@ -27,7 +27,7 @@ export default function plugin_server_assets(app) {
                         const bytes = await file.bytes();
                         const base64 = bytes2base64(bytes);
                         client_assets[pathname] = {
-                            mime: MIME.resolve(file.name),
+                            mime: http.toMIME(file.name),
                             data: base64,
                         };
                     }
@@ -41,7 +41,7 @@ export default function plugin_server_assets(app) {
                         const bytes = await file.bytes();
                         const base64 = bytes2base64(bytes);
                         static_assets[pathname] = {
-                            mime: MIME.resolve(file.name),
+                            mime: http.toMIME(file.name),
                             data: base64,
                         };
                     }

package/lib/private/build/server/plugin/native-addons.js

@@ -1,8 +1,7 @@
 import E from "#errors";
-import log from "#log";
 import fs from "@rcompat/fs";
-import { createRequire } from "node:module";
-const requirer = createRequire(import.meta.url);
+import runtime from "@rcompat/runtime";
+const requirer = runtime.toRequire(import.meta.url);
 export default function plugin_server_store(app) {
     return {
         name: "primate/server/native-addons",
@@ -27,17 +26,16 @@ export default function plugin_server_store(app) {
                             filter: info => info.path.endsWith(".node"),
                         });
                         if (node_files.length > 0) {
-                            const platform = process.platform;
-                            const arch = process.arch;
-                            let node_file = node_files.find(f => f.path.includes(`${platform}-${arch}`));
-                            node_file ??= node_files.find(f => f.path.includes(platform));
+                            const { os, arch } = runtime;
+                            let node_file = node_files.find(f => f.path.includes(`${os}-${arch}`));
+                            node_file ??= node_files.find(f => f.path.includes(os));
                             if (node_file === undefined)
                                 throw E.build_missing_binary_addon();
                             const addon_name = node_files[0].name;
                             const dest = app.path.build.join("native", addon_name);
                             await dest.directory.create();
                             await node_files[0].copy(dest);
-                            log.info("copied native addon {0}", addon_name);
+                            app.log.info `copied native addon ${addon_name}`;
                             return {
                                 path: `./native/${addon_name}`,
                                 external: true,

package/lib/private/build/server/plugin/node-imports.js

@@ -1,21 +1,19 @@
-import fs from "@rcompat/fs";
-import { createRequire } from "node:module";
-const core_pkg = await fs.project.package(import.meta.dirname);
-const core_root = core_pkg.directory.path;
-const requirer = createRequire(import.meta.url);
+import runtime from "@rcompat/runtime";
+const root = (await runtime.projectRoot(import.meta.dirname)).path;
+const requirer = runtime.toRequire(import.meta.url);
 export default function plugin_server_node_imports(_app) {
     return {
         name: "primate/server/node-imports",
         setup(build) {
             build.onResolve({ filter: /^#/ }, async (args) => {
                 // only touch imports coming from @primate/core sources
-                if (!args.importer || !args.importer.startsWith(core_root + "/")) {
+                if (!args.importer || !args.importer.startsWith(root + "/")) {
                     return null;
                 }
                 try {
                     // anchor resolution at core_root we use our package.json "imports"
                     const module_path = requirer.resolve(args.path, {
-                        paths: [core_root],
+                        paths: [root],
                     });
                     return {
                         path: module_path,

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

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

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

@@ -0,0 +1,111 @@
+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",
+        setup(build) {
+            build.onResolve({ filter: /.*/ }, async (args) => {
+                if (args.pluginData === "primate-server-route-client-inner")
+                    return null;
+                if (args.namespace === "primate-server-route-client")
+                    return null;
+                if (intercept(args, app.path.views))
+                    return null;
+                const result = await build.resolve(args.path, {
+                    resolveDir: args.resolveDir,
+                    kind: args.kind,
+                    pluginData: "primate-server-route-client-inner",
+                });
+                if (result.errors.length > 0 || !result.path)
+                    return null;
+                const resolved = fs.ref(result.path);
+                if (!resolved.path.startsWith(app.path.routes.path + "/"))
+                    return null;
+                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" };
+            });
+            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} };
+        `;
+                return { contents, loader: "js", resolveDir: app.root.path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=route-client.js.map