@primate/core 0.8.8 → 0.9.0

package/lib/private/App.d.ts

@@ -19,7 +19,7 @@ export default class App {
         error(error: unknown): void;
     };
     init(): Promise<this>;
-    register(created: Created): void;
+    module(created: Created): void;
     build_hooks(app: BuildApp): Promise<BuildApp>;
     serve_hooks(app: ServeApp): Promise<ServeApp>;
     get handle_hooks(): import("./index.js").HandleHook[];
@@ -29,7 +29,7 @@ export default class App {
         client: "client";
         config: "config";
         error_html: "error.html";
-        pages: "pages";
+        templates: "templates";
         routes: "routes";
         static: "static";
         stores: "stores";
@@ -43,7 +43,7 @@ export default class App {
         readonly client: FileRef;
         readonly config: FileRef;
         readonly error_html: FileRef;
-        readonly pages: FileRef;
+        readonly templates: FileRef;
         readonly routes: FileRef;
         readonly static: FileRef;
         readonly stores: FileRef;

package/lib/private/App.js

@@ -4,6 +4,7 @@ import logger from "#logger";
 import create from "#module/create";
 import TargetManager from "#target/Manager";
 import dict from "@rcompat/dict";
+import fs from "@rcompat/fs";
 import is from "@rcompat/is";
 import p from "pema";
 export default class App {
@@ -31,11 +32,17 @@ export default class App {
         this.#root = root;
         this.#config = config;
         for (const module of config.modules)
-            this.register(create(module));
+            this.module(create(module));
         this.#path = dict.map({
             ...location,
-            build: flags.outdir,
+            build: "build",
         }, (_, path) => root.join(path));
+        if (flags.outdir.startsWith("/")) {
+            this.#path.build = fs.ref(flags.outdir);
+        }
+        else {
+            this.#path.build = root.join(flags.outdir);
+        }
         this.#mode = flags.mode;
         this.#target = new TargetManager(this);
         this.#target_name = flags.target;
@@ -50,7 +57,7 @@ export default class App {
         this.#target.set(this.#target_name);
         return this;
     }
-    register(created) {
+    module(created) {
         if (this.#module_names.has(created.name)) {
             throw E.app_duplicate_module(created.name);
         }

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

@@ -1,27 +1,36 @@
 import App from "#App";
-import type Binder from "#Binder";
+import type { Loader } from "#build/Loader";
 import type ServeApp from "#serve/App";
 import type { FileRef } from "@rcompat/fs";
 import type { Dict } from "@rcompat/type";
 import type { Plugin } from "esbuild";
 type PluginType = "server" | "client";
+type ExtensionQuery = "backend" | "frontend" | "bundler";
 export default class BuildApp extends App {
     #private;
     buildInit(): Promise<void>;
-    get extensions(): string[];
     get id(): string;
     get paths(): Dict<string[]>;
-    get frontendExtensions(): string[];
-    get frontends(): Map<string, string[]>;
     get conditions(): Set<string>;
+    backends(): Map<string, {
+        type: "backend";
+        extensions: string[];
+        onLoad: import("#build/Loader").OnLoad;
+    }>;
+    frontends(options?: {
+        client?: boolean;
+    }): Map<string, Loader<"frontend">>;
+    register(name: string, loader: Loader): void;
+    extensions(query: ExtensionQuery, options?: {
+        client?: boolean;
+    }): string[];
     addRoot(name: string, source: string): void;
     get roots(): Dict<string>;
     plugin(type: PluginType, plugin: Plugin): void;
     plugins(type: PluginType): Plugin[];
     entrypoint(code: string): void;
     get entrypoints(): string;
-    binder(file: FileRef): Binder | undefined;
-    bind(extension: string, binder: Binder): void;
+    load(file: FileRef): Loader | undefined;
     done(fn: () => void): void;
     cleanup(): void;
     basename(file: FileRef, directory: FileRef): string;

package/lib/private/build/App.js

@@ -1,44 +1,80 @@
 import App from "#App";
 import build from "#build/hook";
+import E from "#errors";
 import resolve_paths from "#paths";
 import s_layout_depth from "#symbol/layout-depth";
+function is_frontend(loader) {
+    return loader.type === "frontend";
+}
+function is_backend(loader) {
+    return loader.type === "backend";
+}
 export default class BuildApp extends App {
-    #frontends = new Map();
+    #loaders = new Map([
+        ["javascript", {
+                type: "backend",
+                extensions: [".js"],
+                onLoad: file => file.text(),
+            }],
+        ["typescript", {
+                type: "backend",
+                extensions: [".ts"],
+                onLoad: file => file.text(),
+            }],
+    ]);
     #conditions = new Set();
     #postbuild = [];
     #roots = {};
     #id = crypto.randomUUID().slice(0, 8);
     #session_active = false;
     #paths;
-    #bindings = [
-        [".js", file => file.text()],
-        [".ts", file => file.text()],
-    ];
     #plugins = [];
     #entrypoint_imports = [];
     async buildInit() {
         this.#paths = await resolve_paths(this);
         await build(this);
     }
-    get extensions() {
-        const builtin = [".ts", ".js", ".json"];
-        return [...builtin, ...this.#bindings.map(([extension]) => extension)];
-    }
     get id() {
         return this.#id;
     }
     get paths() {
         return this.#paths;
     }
-    get frontendExtensions() {
-        return [...this.#frontends.values()].flat();
-    }
-    get frontends() {
-        return this.#frontends;
-    }
     get conditions() {
         return this.#conditions;
     }
+    backends() {
+        return new Map([...this.#loaders.entries()]
+            .filter((entry) => is_backend(entry[1])));
+    }
+    frontends(options = {}) {
+        return new Map([...this.#loaders.entries()]
+            .filter((entry) => is_frontend(entry[1]))
+            .filter(([, frontend]) => options.client === undefined ||
+            frontend.client === options.client));
+    }
+    register(name, loader) {
+        const extensions = new Set(loader.extensions);
+        for (const [existing_name, existing] of this.#loaders) {
+            if (existing_name === name)
+                continue;
+            const duplicate = existing.extensions.find(extension => extensions.has(extension));
+            if (duplicate !== undefined)
+                throw E.view_duplicate_extension(duplicate);
+        }
+        this.#loaders.set(name, loader);
+    }
+    extensions(query, options = {}) {
+        if (query === "backend") {
+            return [...this.backends().values()].flatMap(backend => backend.extensions);
+        }
+        if (query === "frontend") {
+            return [...this.frontends(options).values()]
+                .flatMap(frontend => frontend.extensions);
+        }
+        return [".json", ...this.#loaders.values()
+                .flatMap(loader => loader.extensions)];
+    }
     addRoot(name, source) {
         this.#roots[name] = source;
     }
@@ -59,16 +95,15 @@ export default class BuildApp extends App {
     get entrypoints() {
         return this.#entrypoint_imports.join("\n");
     }
-    binder(file) {
-        return this.#bindings
-            .toSorted(([a], [b]) => a.length > b.length ? -1 : 1)
-            .find(([extension]) => file.path.endsWith(extension))?.[1];
-    }
-    bind(extension, binder) {
-        if (this.extensions.includes(extension)) {
-            throw new Error(`${extension} already bound`);
-        }
-        this.#bindings.push([extension, binder]);
+    load(file) {
+        return [...this.#loaders.values()]
+            .flatMap(loader => loader.extensions.map(extension => ({
+            extension,
+            loader,
+        })))
+            .toSorted((a, b) => a.extension.length > b.extension.length ? -1 : 1)
+            .find(({ extension }) => file.path.endsWith(extension))
+            ?.loader;
     }
     done(fn) {
         this.#postbuild.push(fn);
@@ -78,7 +113,7 @@ export default class BuildApp extends App {
     }
     basename(file, directory) {
         const relative = file.debase(directory);
-        const extensions = this.extensions
+        const extensions = this.extensions("bundler")
             .toSorted((a, b) => a.length > b.length ? -1 : 1);
         for (const extension of extensions) {
             if (relative.path.endsWith(extension)) {

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

@@ -0,0 +1,17 @@
+import type { FileRef } from "@rcompat/fs";
+import type { MaybePromise } from "@rcompat/type";
+type LoaderType = "frontend" | "backend";
+type OnLoad = (file: FileRef, options: {
+    build: {
+        id: string;
+    };
+}) => MaybePromise<string>;
+type Loader<T extends LoaderType = LoaderType> = {
+    type: T;
+    extensions: string[];
+    onLoad: OnLoad;
+} & (T extends "frontend" ? {
+    client: boolean;
+} : {});
+export type { Loader, LoaderType, OnLoad };
+//# sourceMappingURL=Loader.d.ts.map

package/lib/private/build/Loader.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Loader.js.map

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

@@ -16,8 +16,9 @@ const write_bootstrap = async (app) => {
     const build_start_script = `
     import serve from "primate/serve";
     import views from "app:views";
-    import routes from "app:routes";
     import pages from "app:pages";
+    import routes from "app:routes";
+    import templates from "app:templates";
     import assets from "app:assets";
     ${migrate_auto ? `import migrations from "app:migrations";` : ""}
     ${migrate_auto ? `import autoapply from "app:migrations/autoapply";` : ""}
@@ -38,6 +39,7 @@ const write_bootstrap = async (app) => {
       routes,
       views,
       pages,
+      templates,
       session: session_config,
       mode: "${app.mode}",
       target: "${app.target.name}",
@@ -80,7 +82,7 @@ export default async function build_client(app) {
             ...user_entrypoints(app),
         },
         conditions: ["style", "browser", "default", "module", ...conditions],
-        resolveExtensions: [".ts", ".js", ...app.frontendExtensions],
+        resolveExtensions: [".ts", ".js", ...app.extensions("frontend", { client: true })],
         ...await tsconfig.exists() ? { tsconfig: tsconfig.path } : {},
         bundle: true,
         format: "esm",

package/lib/private/build/client/plugin/app-request.js

@@ -3,8 +3,8 @@ export default function plugin_client_request(app) {
         name: "primate/client/app/request",
         setup(build) {
             build.onResolve({ filter: /^app:request$/ }, ({ importer }) => {
-                const frontend = [...app.frontends.entries()]
-                    .find(([, exts]) => exts.some(ext => importer.endsWith(ext)));
+                const frontend = [...app.frontends().entries()]
+                    .find(([, { extensions }]) => extensions.some(ext => importer.endsWith(ext)));
                 return frontend !== undefined
                     ? { namespace: "request", path: frontend[0] }
                     : undefined;

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

@@ -6,7 +6,8 @@ export default function plugin_client_frontend(app) {
                 return { namespace: "frontends", path };
             });
             build.onLoad({ filter: /app:frontends/ }, async () => {
-                const contents = [...app.frontends.keys()].map(name => `export { app as ${name} } from "@primate/${name}";`).join("\n");
+                const contents = [...app.frontends({ client: true }).entries()]
+                    .map(([name]) => `export { app as ${name} } from "@primate/${name}";`).join("\n");
                 return { contents, resolveDir: app.root.path };
             });
         },

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

@@ -9,12 +9,12 @@ export default function plugin_client_route_module(app) {
             });
             build.onLoad({ filter: /.*/, namespace: "primate-route" }, async (args) => {
                 const base = app.path.routes.join(args.path);
-                for (const ext of app.extensions) {
+                for (const ext of app.extensions("bundler")) {
                     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" })
+                        const loader = app.load(candidate);
+                        const contents = loader
+                            ? await loader.onLoad(candidate, { build: { id: app.id } })
                             : await candidate.text();
                         return {
                             contents,

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

@@ -7,6 +7,10 @@ export default function plugin_client_view(app) {
                 const name = args.path.slice("view:".length);
                 return { path: app.root.join(location.views, name).path };
             });
+            build.onResolve({ filter: /^page:/ }, args => {
+                const name = args.path.slice("page:".length);
+                return { path: app.root.join(location.routes, name).path };
+            });
         },
     };
 }

package/lib/private/build/hook.js

@@ -22,7 +22,7 @@ async function pre(app) {
     await app.runpath(location.client).create();
     const stamp = app.runpath("client", "server-stamp.js");
     await stamp.write("export default 0;\n");
-    const router = await $router(app.path.routes, app.extensions);
+    const router = await $router(app.path.routes, app.extensions("backend"), app.extensions("frontend"));
     app.set(s_layout_depth, router.depth("layout"));
     const session_ts = app.path.config.join("session.ts");
     const session_js = app.path.config.join("session.js");

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

@@ -11,7 +11,7 @@ import plugin_route from "#build/server/plugin/route";
 import plugin_route_client from "#build/server/plugin/route-client";
 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_virtual_templates from "#build/server/plugin/virtual-templates";
 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";
@@ -22,7 +22,7 @@ export default async function build_server(app) {
     app.plugin("server", plugin_view(app));
     if (app.mode === "development")
         app.plugin("server", plugin_live_reload(app));
-    app.plugin("server", plugin_virtual_pages(app));
+    app.plugin("server", plugin_virtual_templates(app));
     app.plugin("server", plugin_virtual_routes(app));
     app.plugin("server", plugin_route_client(app));
     app.plugin("server", plugin_route(app));
@@ -55,7 +55,7 @@ export default async function build_server(app) {
       const require = __createRequire(import.meta.url);`,
         },
         nodePaths: [app.root.join("node_modules").path],
-        resolveExtensions: app.extensions,
+        resolveExtensions: app.extensions("bundler"),
         absWorkingDir: app.root.path,
         ...await tsconfig_json.exists() ? { tsconfig: tsconfig_json.path } : {},
         conditions: [

package/lib/private/build/server/plugin/app-request.js

@@ -3,8 +3,8 @@ export default function plugin_server_request(app) {
         name: "primate/server/app/request",
         setup(build) {
             build.onResolve({ filter: /^app:request$/ }, ({ importer }) => {
-                const frontend = [...app.frontends.entries()]
-                    .find(([, exts]) => exts.some(ext => importer.endsWith(ext)));
+                const frontend = [...app.frontends().entries()]
+                    .find(([, { extensions }]) => extensions.some(ext => importer.endsWith(ext)));
                 return frontend !== undefined
                     ? { namespace: "request", path: frontend[0] }
                     : undefined;

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

@@ -1,19 +1,19 @@
 import fs from "@rcompat/fs";
 export default function plugin_server_frontend(app) {
-    const filter = new RegExp(`(${app.frontendExtensions.map(e => e.replace(".", "\\.")).join("|")})$`);
+    const frontend_extensions = app.extensions("frontend");
+    const filter = new RegExp(`(${frontend_extensions.map(e => e.replace(".", "\\.")).join("|")})$`);
     return {
         name: "primate/server/frontend",
         setup(build) {
-            if (app.frontendExtensions.length === 0)
+            if (frontend_extensions.length === 0)
                 return;
             build.onLoad({ filter, namespace: "file" }, async (args) => {
                 const file = fs.ref(args.path);
-                const binder = app.binder(file);
-                if (!binder)
+                const loader = app.load(file);
+                if (!loader)
                     return null;
-                const contents = await binder(file, {
+                const contents = await loader.onLoad(file, {
                     build: { id: app.id },
-                    context: "views",
                 });
                 return { contents, loader: "js", resolveDir: file.directory.path };
             });

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

@@ -13,7 +13,7 @@ export default function plugin_server_route(app) {
             build.onLoad({ filter: /.*/, namespace: "primate-route" }, async (args) => {
                 const relative = args.path;
                 const base = path_routes.join(relative);
-                const extensions = app.extensions;
+                const extensions = app.extensions("bundler");
                 let file;
                 let extension;
                 for (const e of extensions) {
@@ -29,12 +29,11 @@ export default function plugin_server_route(app) {
                 }
                 const resolveDir = file.directory.path;
                 const watchFiles = [file.path];
-                const binder = app.binder(file);
-                if (!binder)
+                const loader = app.load(file);
+                if (!loader)
                     return { contents: empty, loader: "js", resolveDir, watchFiles };
-                const compiled = await binder(file, {
+                const compiled = await loader.onLoad(file, {
                     build: { id: app.id },
-                    context: "routes",
                 });
                 return {
                     contents: compiled,

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

@@ -39,22 +39,29 @@ export default function plugin_server_view(app) {
             });
             build.onResolve({ filter: /^view:/ }, async (args) => {
                 const name = args.path.slice("view:".length);
-                for (const ext of app.extensions) {
+                for (const ext of app.extensions("bundler")) {
                     const file = app.path.views.join(`${name}${ext}`);
                     if (await file.exists()) {
-                        return { path: file.path, namespace: "primate-view-original" };
+                        return { path: file.path, namespace: "primate-component-source" };
                     }
                 }
                 return null;
             });
-            build.onLoad({ filter: /.*/, namespace: "primate-view-original" }, async (args) => {
+            build.onResolve({ filter: /^page:/ }, async (args) => {
+                const name = args.path.slice("page:".length);
+                const file = app.path.routes.join(name);
+                if (await file.exists()) {
+                    return { path: file.path, namespace: "primate-component-source" };
+                }
+                return null;
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-component-source" }, async (args) => {
                 const file = fs.ref(args.path);
-                const binder = app.binder(file);
-                if (binder === undefined)
+                const loader = app.load(file);
+                if (loader === undefined)
                     return null;
-                const contents = await binder(file, {
+                const contents = await loader.onLoad(file, {
                     build: { id: app.id },
-                    context: "views",
                 });
                 return { contents, loader: "js", resolveDir: file.directory.path };
             });

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

@@ -1,13 +1,24 @@
+import E from "#errors";
 import fs from "@rcompat/fs";
 export default function plugin_server_views(app) {
     return {
         name: "primate/server/views",
         setup(build) {
+            const frontend_extensions = app.extensions("frontend");
+            const route_pages = async () => app.path.routes.files({
+                filter: file => frontend_extensions.some(ext => file.path.endsWith(ext)),
+                recursive: true,
+            });
             build.onResolve({ filter: /^app:views/ }, () => {
                 return { path: "views-virtual", namespace: "primate-views" };
             });
+            build.onResolve({ filter: /^app:pages/ }, () => {
+                return { path: "pages-virtual", namespace: "primate-pages" };
+            });
             build.onLoad({ filter: /.*/, namespace: "primate-views" }, async () => {
                 const files = await app.path.views.files({ recursive: true });
+                const pages = await route_pages();
+                const page_keys = new Set();
                 const roots = Object.keys(app.roots);
                 const contents = `
         const view = [];
@@ -18,6 +29,17 @@ export default function plugin_server_views(app) {
             view.push(["${fs.webpath(path)}", view${i}]);`;
                 }).join("\n")}
 
+        ${pages.map((file, i) => {
+                    const key = fs.webpath(app.basename(file, app.path.routes));
+                    if (page_keys.has(key))
+                        throw E.build_duplicate_route_page(key);
+                    page_keys.add(key);
+                    const path = file.debase(app.path.routes).path.replace(/^[\\/]/, "");
+                    return `
+            import * as page${i} from "${fs.webpath(`page:${path}`)}";
+            view.push(["$page/${key}", page${i}]);`;
+                }).join("\n")}
+
         ${roots.map((filename, i) => `
           import * as root${i} from "app:root/${filename}";
           view.push(["${filename}", root${i}]);
@@ -30,6 +52,28 @@ export default function plugin_server_views(app) {
                     resolveDir: app.root.path,
                 };
             });
+            build.onLoad({ filter: /.*/, namespace: "primate-pages" }, async () => {
+                const pages = await route_pages();
+                const page_keys = new Set();
+                const contents = `
+        const pages = [];
+        ${pages.map((file, i) => {
+                    const key = fs.webpath(app.basename(file, app.path.routes));
+                    if (page_keys.has(key))
+                        throw E.build_duplicate_route_page(key);
+                    page_keys.add(key);
+                    const path = file.debase(app.path.routes).path.replace(/^[\\/]/, "");
+                    return `
+            pages.push(["${key}", "$page/${fs.webpath(path)}"]);`;
+                }).join("\n")}
+
+        export default pages;`;
+                return {
+                    contents,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                };
+            });
         },
     };
 }

package/lib/private/build/server/plugin/virtual-routes.js

@@ -3,11 +3,14 @@ function is_hook_file(p) {
     return basename === "+hook" || basename.startsWith("+hook.");
 }
 function plugin_server_virtual_routes(app) {
-    const extension_pattern = new RegExp(`(${app.extensions.map(e => e.replace(".", "\\.")).join("|")})$`);
+    const route_extensions = app.extensions("backend");
+    const frontend_extensions = app.extensions("frontend");
+    const extension_pattern = new RegExp(`(${route_extensions.map(e => e.replace(".", "\\.")).join("|")})$`);
     function is_route_file(f) {
         return !f.name.endsWith("~") &&
             !f.name.startsWith(".") &&
             !f.name.startsWith("-") &&
+            !frontend_extensions.some(ext => f.path.endsWith(ext)) &&
             extension_pattern.test(f.path);
     }
     return {

package/lib/private/build/server/plugin/virtual-templates.d.ts

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

package/lib/private/build/server/plugin/{virtual-pages.js → virtual-templates.js}

@@ -1,33 +1,33 @@
 import runtime from "@rcompat/runtime";
 const core = await runtime.projectRoot(import.meta.dirname);
-export default function plugin_server_virtual_pages(app) {
+export default function plugin_server_virtual_templates(app) {
     return {
-        name: "primate/server/virtual/pages",
+        name: "primate/server/virtual/templates",
         setup(build) {
-            build.onResolve({ filter: /^app:pages$/ }, () => {
-                return { path: "pages-virtual", namespace: "primate-pages" };
+            build.onResolve({ filter: /^app:templates$/ }, () => {
+                return { path: "templates-virtual", namespace: "primate-templates" };
             });
-            build.onLoad({ filter: /.*/, namespace: "primate-pages" }, async () => {
+            build.onLoad({ filter: /.*/, namespace: "primate-templates" }, async () => {
                 const filter = /^.*\.html$/ui;
                 const defaults = core.join("lib", "private", "defaults");
-                const pages = {};
+                const templates = {};
                 for (const file of await defaults.files({ filter })) {
-                    pages[file.name] = file;
+                    templates[file.name] = file;
                 }
-                if (await app.path.pages.exists()) {
-                    for (const file of await app.path.pages.files({ filter })) {
-                        pages[file.name] = file;
+                if (await app.path.templates.exists()) {
+                    for (const file of await app.path.templates.files({ filter })) {
+                        templates[file.name] = file;
                     }
                 }
-                const entries = await Promise.all(Object.entries(pages).map(async ([name, file]) => {
+                const entries = await Promise.all(Object.entries(templates).map(async ([name, file]) => {
                     const text = await file.text();
                     return `"${name}": ${JSON.stringify(text)}`;
                 }));
                 const contents = `
-          const pages = {
+          const templates = {
             ${entries.join(",\n")}
           };
-          export default pages;
+          export default templates;
         `;
                 return {
                     contents,
@@ -38,4 +38,4 @@ export default function plugin_server_virtual_pages(app) {
         },
     };
 }
-//# sourceMappingURL=virtual-pages.js.map
+//# sourceMappingURL=virtual-templates.js.map

package/lib/private/build/shared/plugin/app-request.js

@@ -4,8 +4,8 @@ export default function plugin_shared_app_request(app) {
         setup(build) {
             build.onResolve({ filter: /^app:/ }, ({ path, importer }) => {
                 const framework = path.slice(4);
-                const exts = app.frontends.get(framework);
-                return exts?.some(ext => importer.endsWith(ext))
+                const frontend = app.frontends().get(framework);
+                return frontend?.extensions.some(ext => importer.endsWith(ext))
                     ? { namespace: "app-frontend", path: framework }
                     : undefined;
             });

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

@@ -5,7 +5,7 @@ export default interface ViewOptions extends ResponseInit {
         style_src?: string[];
     };
     head?: string;
-    page?: string;
+    template?: string;
     partial?: boolean;
     placeholders?: Omit<Dict, "body" | "head">;
 }