@primate/core 0.6.2 → 0.7.0

package/lib/private/db/testSQL.d.ts

@@ -0,0 +1,50 @@
+import type SQLDB from "#db/SQLDB";
+import test from "@rcompat/test";
+declare const users: {
+    table: string;
+    pk: string;
+    types: {
+        id: "u32";
+        name: "string";
+        age: "u8";
+    };
+};
+declare const posts: {
+    table: string;
+    pk: string;
+    types: {
+        id: "u32";
+        user_id: "u32";
+        title: "string";
+    };
+};
+declare const transactions: {
+    table: string;
+    pk: string;
+    types: {
+        id: "u64";
+        amount: "u128";
+        memo: "string";
+    };
+};
+declare const json: {
+    table: string;
+    pk: string;
+    types: {
+        readonly id: "string";
+        readonly data: "json";
+    };
+};
+type Setup = {
+    $: (body: () => Promise<void>) => Promise<void>;
+    users: typeof users;
+    posts: typeof posts;
+    transactions: typeof transactions;
+    json: typeof json;
+    test: typeof test;
+    query_equals: (name: string, work: Work, expected: string) => void;
+};
+type Work = () => Promise<unknown>;
+export default function testSQL(db: SQLDB, cb: (setup: Setup) => void): void;
+export {};
+//# sourceMappingURL=testSQL.d.ts.map

package/lib/private/db/testSQL.js

@@ -0,0 +1,196 @@
+import { Code } from "#db/errors";
+import test from "@rcompat/test";
+import p from "pema";
+const dt = {
+    u8: p.u8.datatype,
+    u32: p.u32.datatype,
+    u64: p.u64.datatype,
+    u128: p.u128.datatype,
+    string: p.string.datatype,
+};
+const users = {
+    table: "users",
+    pk: "id",
+    types: { id: dt.u32, name: dt.string, age: dt.u8 },
+};
+const posts = {
+    table: "posts",
+    pk: "id",
+    types: {
+        id: dt.u32, user_id: dt.u32, title: dt.string,
+    },
+};
+const transactions = {
+    table: "transactions",
+    pk: "id",
+    types: {
+        id: dt.u64, amount: dt.u128, memo: dt.string,
+    },
+};
+const json = {
+    table: "json",
+    pk: "id",
+    types: { id: dt.string, data: "json" },
+};
+const pk_config = { name: "id", generate: true };
+function normalize(sql) {
+    return sql.replace(/\s+/g, " ").trim();
+}
+export default function testSQL(db, cb) {
+    async function $(body) {
+        await db.schema.create("users", pk_config, users.types);
+        await db.schema.create("posts", pk_config, posts.types);
+        await db.schema.create("transactions", pk_config, transactions.types);
+        await db.schema.create("json", pk_config, json.types);
+        await body();
+        await db.schema.delete("users");
+        await db.schema.delete("posts");
+        await db.schema.delete("transactions");
+        await db.schema.delete("json");
+    }
+    function query_equals(name, work, expected) {
+        test.case(name, async (assert) => {
+            await $(async () => {
+                await work();
+                assert(normalize(db.explain.users.query)).equals(normalize(expected));
+            });
+        });
+    }
+    cb({
+        $,
+        users,
+        posts,
+        transactions,
+        json,
+        test,
+        query_equals,
+    });
+    test.ended(() => db.close());
+    test.group("sql", () => {
+        test.case("select with input and output", async (assert) => {
+            await $(async () => {
+                await db.create(users, { id: 1, name: "alice", age: 30 });
+                await db.create(users, { id: 2, name: "bob", age: 25 });
+                const findByAge = db.sql({
+                    input: p({ age: p.u8 }),
+                    query: "SELECT name FROM users WHERE age > :age",
+                    output: p.array(p({ name: p.string })),
+                });
+                const results = await findByAge({ age: 24 });
+                assert(results.length).equals(2);
+                assert(results[0].name).equals("alice");
+                assert(results[1].name).equals("bob");
+            });
+        });
+        test.case("select with no input", async (assert) => {
+            await $(async () => {
+                await db.create(users, { id: 1, name: "alice", age: 30 });
+                await db.create(users, { id: 2, name: "bob", age: 25 });
+                const findAll = db.sql({
+                    query: "SELECT name FROM users",
+                    output: p.array(p({ name: p.string })),
+                });
+                const results = await findAll();
+                assert(results.length).equals(2);
+            });
+        });
+        test.case("insert with no output", async (assert) => {
+            await $(async () => {
+                const insert = db.sql({
+                    input: p({ name: p.string, age: p.u8 }),
+                    query: "INSERT INTO users (name, age) VALUES (:name, :age)",
+                });
+                await insert({ name: "charlie", age: 20 });
+                const rows = await db.read(users, { where: { name: "charlie" } });
+                assert(rows.length).equals(1);
+                assert(rows[0].name).equals("charlie");
+            });
+        });
+        test.case("update with no output", async (assert) => {
+            await $(async () => {
+                await db.create(users, { id: 1, name: "alice", age: 30 });
+                const updateAge = db.sql({
+                    input: p({ age: p.u8, name: p.string }),
+                    query: "UPDATE users SET age = :age WHERE name = :name",
+                });
+                await updateAge({ age: 31, name: "alice" });
+                const rows = await db.read(users, { where: { name: "alice" } });
+                assert(rows[0].age).equals(31);
+            });
+        });
+        test.case("delete with no output", async (assert) => {
+            await $(async () => {
+                await db.create(users, { id: 1, name: "alice", age: 30 });
+                const deleteByName = db.sql({
+                    input: p({ name: p.string }),
+                    query: "DELETE FROM users WHERE name = :name",
+                });
+                await deleteByName({ name: "alice" });
+                const rows = await db.read(users, { where: {} });
+                assert(rows.length).equals(0);
+            });
+        });
+        test.case("input validation fails", async (assert) => {
+            await $(async () => {
+                const findByAge = db.sql({
+                    input: p({ age: p.u8 }),
+                    query: "SELECT name FROM users WHERE age > :age",
+                    output: p.array(p({ name: p.string })),
+                });
+                try {
+                    await findByAge({ age: -1 });
+                    assert(false).true();
+                }
+                catch {
+                    assert(true).true();
+                }
+            });
+        });
+        test.case("empty result", async (assert) => {
+            await $(async () => {
+                const findByAge = db.sql({
+                    input: p({ age: p.u8 }),
+                    query: "SELECT name FROM users WHERE age > :age",
+                    output: p.array(p({ name: p.string })),
+                });
+                const results = await findByAge({ age: 100 });
+                assert(results.length).equals(0);
+            });
+        });
+        test.case("placeholder in input but not in query", async (assert) => {
+            await $(async () => {
+                assert(() => db.sql({
+                    // @ts-expect-error 'name' in put but missing in query
+                    input: p({ age: p.u8, name: p.string }),
+                    query: "SELECT name FROM users WHERE age > :age",
+                })).throws(Code.sql_placeholder_missing);
+            });
+        });
+        test.case("placeholder in query but not in input", async (assert) => {
+            await $(async () => {
+                assert(() => db.sql({
+                    // @ts-expect-error 'name' required but missing in input
+                    input: p({ age: p.u8 }),
+                    query: "SELECT name FROM users WHERE age > :age AND name = :name",
+                })).throws(Code.sql_input_missing);
+            });
+        });
+        test.case("output validation fails", async (assert) => {
+            await $(async () => {
+                await db.create(users, { id: 1, name: "alice", age: 30 });
+                const findAll = db.sql({
+                    query: "SELECT name FROM users",
+                    output: p.array(p({ name: p.u8 })),
+                });
+                try {
+                    await findAll();
+                    assert(false).true();
+                }
+                catch {
+                    assert(true).true();
+                }
+            });
+        });
+    });
+}
+//# sourceMappingURL=testSQL.js.map

package/lib/private/errors.d.ts

@@ -1,23 +1,29 @@
 import type { FileRef } from "@rcompat/fs";
+import type http from "@rcompat/http";
+import type { Method } from "@rcompat/http";
 import type ParseError from "pema/ParseError";
+type MIME = typeof http.MIME;
+type MIMEValue = MIME[keyof MIME];
 declare function app_reserved_directory(directory: string): import("@rcompat/error").TemplateError;
 declare function app_duplicate_module(name: string): import("@rcompat/error").TemplateError;
 declare function build_missing_binary_addon(): import("@rcompat/error").TemplateError;
 declare function build_missing_route(route: string, file: FileRef): import("@rcompat/error").TemplateError;
-declare function build_multiple_db_drivers(drivers: string[]): import("@rcompat/error").TemplateError;
 declare function build_live_reload_failed(filename: string, cause: Error): import("@rcompat/error").TemplateError;
 declare function build_previous_build_exists(file: FileRef): import("@rcompat/error").TemplateError;
-declare function config_tsconfig_has_paths(): import("@rcompat/error").TemplateError;
+declare function build_no_path_schema(route: string): import("@rcompat/error").TemplateError;
+declare function build_body_requires_content_type(): 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;
 declare function config_missing(property: string): import("@rcompat/error").TemplateError;
+declare function config_failed_to_parse_tsconfig(path: FileRef, cause: Error): import("@rcompat/error").TemplateError;
 declare function frontend_missing(view: string, module?: string): import("@rcompat/error").TemplateError;
 declare function frontend_missing_app_js(): import("@rcompat/error").TemplateError;
 declare function request_unsupported_mime(path: string, mime: string): import("@rcompat/error").TemplateError;
 declare function request_unparsable_mime(path: string, mime: string, cause: Error): import("@rcompat/error").TemplateError;
-declare function request_unexpected_body(expected: string, actual: string): import("@rcompat/error").TemplateError;
+declare function request_body_already_parsed(): import("@rcompat/error").TemplateError;
 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 hook_route_functions_not_allowed(file: string): import("@rcompat/error").TemplateError;
 declare function hook_not_allowed(file: string): import("@rcompat/error").TemplateError;
@@ -28,9 +34,10 @@ declare function hook_bad_return(): import("@rcompat/error").TemplateError;
 declare function session_missing_id(): import("@rcompat/error").TemplateError;
 declare function session_id_string(): import("@rcompat/error").TemplateError;
 declare function session_id_data(): import("@rcompat/error").TemplateError;
+declare function session_handle_unavailable(): import("@rcompat/error").TemplateError;
 declare function target_missing(target: string, targets: string[]): import("@rcompat/error").TemplateError;
 declare function target_duplicate(target: string): import("@rcompat/error").TemplateError;
-declare function route_missing_verb(route: string, verb: string): import("@rcompat/error").TemplateError;
+declare function route_missing_method(route: string, method: Method): import("@rcompat/error").TemplateError;
 declare function route_invalid_special_file(route: string): import("@rcompat/error").TemplateError;
 declare function route_invalid_parameter(route: string, parameter: string): import("@rcompat/error").TemplateError;
 declare function route_invalid_characters(route: string, regexp: RegExp): import("@rcompat/error").TemplateError;
@@ -40,7 +47,9 @@ declare function view_duplicate_extension(extension: string): import("@rcompat/e
 declare function view_error(view: string, cause: Error): import("@rcompat/error").TemplateError;
 declare function env_invalid_schema(cause: ParseError): import("@rcompat/error").TemplateError;
 declare function env_missing_key(key: string): import("@rcompat/error").TemplateError;
+declare function openapi_no_operation_for(method: Method, path: string): import("@rcompat/error").TemplateError;
 declare const errors: {
+    openapi_no_operation_for: typeof openapi_no_operation_for;
     env_invalid_schema: typeof env_invalid_schema;
     env_missing_key: typeof env_missing_key;
     view_missing: typeof view_missing;
@@ -52,6 +61,7 @@ declare const errors: {
     session_missing_id: typeof session_missing_id;
     session_id_string: typeof session_id_string;
     session_id_data: typeof session_id_data;
+    session_handle_unavailable: typeof session_handle_unavailable;
     hook_route_functions_not_allowed: typeof hook_route_functions_not_allowed;
     hook_not_allowed: typeof hook_not_allowed;
     hook_unused: typeof hook_unused;
@@ -61,9 +71,10 @@ declare const errors: {
     response_invalid_body: typeof response_invalid_body;
     request_unsupported_mime: typeof request_unsupported_mime;
     request_unparsable_mime: typeof request_unparsable_mime;
-    request_unexpected_body: typeof request_unexpected_body;
+    request_body_already_parsed: typeof request_body_already_parsed;
     request_bag_missing_key: typeof request_bag_missing_key;
-    route_missing_verb: typeof route_missing_verb;
+    request_content_type_mismatch: typeof request_content_type_mismatch;
+    route_missing_method: typeof route_missing_method;
     route_invalid_special_file: typeof route_invalid_special_file;
     route_invalid_parameter: typeof route_invalid_parameter;
     route_invalid_characters: typeof route_invalid_characters;
@@ -71,18 +82,64 @@ declare const errors: {
     frontend_missing_app_js: typeof frontend_missing_app_js;
     config_file_missing: typeof config_file_missing;
     config_missing: typeof config_missing;
-    config_tsconfig_has_paths: typeof config_tsconfig_has_paths;
     config_file_empty: typeof config_file_empty;
     config_file_error: typeof config_file_error;
+    config_failed_to_parse_tsconfig: typeof config_failed_to_parse_tsconfig;
     build_missing_binary_addon: typeof build_missing_binary_addon;
     build_missing_route: typeof build_missing_route;
-    build_multiple_db_drivers: typeof build_multiple_db_drivers;
     build_live_reload_failed: typeof build_live_reload_failed;
     build_previous_build_exists: typeof build_previous_build_exists;
+    build_no_path_schema: typeof build_no_path_schema;
+    build_body_requires_content_type: typeof build_body_requires_content_type;
     app_reserved_directory: typeof app_reserved_directory;
     app_duplicate_module: typeof app_duplicate_module;
 };
+export declare const Code: {
+    openapi_no_operation_for: "openapi_no_operation_for";
+    env_invalid_schema: "env_invalid_schema";
+    env_missing_key: "env_missing_key";
+    view_missing: "view_missing";
+    view_missing_default_export: "view_missing_default_export";
+    view_duplicate_extension: "view_duplicate_extension";
+    view_error: "view_error";
+    target_missing: "target_missing";
+    target_duplicate: "target_duplicate";
+    session_missing_id: "session_missing_id";
+    session_id_string: "session_id_string";
+    session_id_data: "session_id_data";
+    session_handle_unavailable: "session_handle_unavailable";
+    hook_route_functions_not_allowed: "hook_route_functions_not_allowed";
+    hook_not_allowed: "hook_not_allowed";
+    hook_unused: "hook_unused";
+    hook_reused_next: "hook_reused_next";
+    hook_no_return: "hook_no_return";
+    hook_bad_return: "hook_bad_return";
+    response_invalid_body: "response_invalid_body";
+    request_unsupported_mime: "request_unsupported_mime";
+    request_unparsable_mime: "request_unparsable_mime";
+    request_body_already_parsed: "request_body_already_parsed";
+    request_bag_missing_key: "request_bag_missing_key";
+    request_content_type_mismatch: "request_content_type_mismatch";
+    route_missing_method: "route_missing_method";
+    route_invalid_special_file: "route_invalid_special_file";
+    route_invalid_parameter: "route_invalid_parameter";
+    route_invalid_characters: "route_invalid_characters";
+    frontend_missing: "frontend_missing";
+    frontend_missing_app_js: "frontend_missing_app_js";
+    config_file_missing: "config_file_missing";
+    config_missing: "config_missing";
+    config_file_empty: "config_file_empty";
+    config_file_error: "config_file_error";
+    config_failed_to_parse_tsconfig: "config_failed_to_parse_tsconfig";
+    build_missing_binary_addon: "build_missing_binary_addon";
+    build_missing_route: "build_missing_route";
+    build_live_reload_failed: "build_live_reload_failed";
+    build_previous_build_exists: "build_previous_build_exists";
+    build_no_path_schema: "build_no_path_schema";
+    build_body_requires_content_type: "build_body_requires_content_type";
+    app_reserved_directory: "app_reserved_directory";
+    app_duplicate_module: "app_duplicate_module";
+};
 export type Code = keyof typeof errors;
-export declare const Code: { [K in Code]: K; };
 export default errors;
 //# sourceMappingURL=errors.d.ts.map

package/lib/private/errors.js

@@ -16,26 +16,29 @@ function build_missing_binary_addon() {
 function build_missing_route(route, file) {
     return t `cannot find route source for ${route} under ${file.path}`;
 }
-function build_multiple_db_drivers(drivers) {
-    const defaults = ["index.ts", "index.js", "default.ts", "default.js"];
-    return t `multiple database drivers ${drivers}, add one of ${defaults}`;
-}
 function build_live_reload_failed(filename, cause) {
     return t `failed to live-reload ${filename}: ${cause}`;
 }
 function build_previous_build_exists(file) {
     return t `${file.path} exists but does not contain a previous build`;
 }
+function build_no_path_schema(route) {
+    const example = "route.with({ path: ... })";
+    return t `route ${route} has dynamic segments but no path schema — declare a path schema in ${example} to use this route from a client`;
+}
+function build_body_requires_content_type() {
+    const b = "contentType";
+    const c = "route.with({ contentType: ..., body: ... })";
+    return t `body schema requires ${b} to be set — declare a contentType in ${c}`;
+}
 const BUILD = error.coded({
     build_missing_binary_addon,
     build_missing_route,
-    build_multiple_db_drivers,
     build_live_reload_failed,
     build_previous_build_exists,
+    build_no_path_schema,
+    build_body_requires_content_type,
 });
-function config_tsconfig_has_paths() {
-    return t `tsconfig.json exists with paths, remove config paths`;
-}
 function config_file_missing() {
     return t `missing ${"config/app.ts"}`;
 }
@@ -48,12 +51,15 @@ function config_file_error(file, cause) {
 function config_missing(property) {
     return t `${property} not configured`;
 }
+function config_failed_to_parse_tsconfig(path, cause) {
+    return t `failed to parse tsconfig at ${path}: ${cause}`;
+}
 const CONFIG = error.coded({
     config_file_missing,
     config_missing,
-    config_tsconfig_has_paths,
     config_file_empty,
     config_file_error,
+    config_failed_to_parse_tsconfig,
 });
 function frontend_missing(view, module) {
     if (module === undefined)
@@ -74,17 +80,21 @@ function request_unsupported_mime(path, mime) {
 function request_unparsable_mime(path, mime, cause) {
     return t `${path}: unparsable MIME type ${mime} (${cause})`;
 }
-function request_unexpected_body(expected, actual) {
-    return t `request body: expected ${expected}, got ${actual}`;
+function request_body_already_parsed() {
+    return t `body is already parsed`;
 }
 function request_bag_missing_key(bag, key) {
     return t `${bag} has no key ${key}`;
 }
+function request_content_type_mismatch(expected, actual) {
+    return t `content-type mismatch: expected ${expected}, got ${actual}`;
+}
 const REQUEST = error.coded({
     request_unsupported_mime,
     request_unparsable_mime,
-    request_unexpected_body,
+    request_body_already_parsed,
     request_bag_missing_key,
+    request_content_type_mismatch,
 });
 function response_invalid_body(body) {
     return t `invalid body ${body} returned from route`;
@@ -128,10 +138,14 @@ function session_id_string() {
 function session_id_data() {
     return t `"both ${"id"} and ${"data"} must be defined or undefined`;
 }
+function session_handle_unavailable() {
+    return t `session handle not available in this context`;
+}
 const SESSION = error.coded({
     session_missing_id,
     session_id_string,
     session_id_data,
+    session_handle_unavailable,
 });
 function target_missing(target, targets) {
     return t `no target ${target}, available targets ${targets}`;
@@ -143,8 +157,8 @@ const TARGET = error.coded({
     target_missing,
     target_duplicate,
 });
-function route_missing_verb(route, verb) {
-    return t `${route} has no verb ${verb}`;
+function route_missing_method(route, method) {
+    return t `${route} has no method ${method}`;
 }
 function route_invalid_special_file(route) {
     return t `${route} is not a valid special file`;
@@ -156,7 +170,7 @@ function route_invalid_characters(route, regexp) {
     return t `${route} may only contain any of ${regexp.source.slice(1, -1)}`;
 }
 const ROUTE = error.coded({
-    route_missing_verb,
+    route_missing_method,
     route_invalid_special_file,
     route_invalid_parameter,
     route_invalid_characters,
@@ -192,6 +206,12 @@ const ENV = error.coded({
     env_invalid_schema,
     env_missing_key,
 });
+function openapi_no_operation_for(method, path) {
+    return t `no operation for ${path} (${method}`;
+}
+const OPENAPI = error.coded({
+    openapi_no_operation_for,
+});
 const errors = {
     ...APP,
     ...BUILD,
@@ -205,7 +225,8 @@ const errors = {
     ...TARGET,
     ...VIEW,
     ...ENV,
+    ...OPENAPI,
 };
-export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
+export const Code = error.names(errors);
 export default errors;
 //# sourceMappingURL=errors.js.map

package/lib/private/frontend.d.ts

@@ -12,11 +12,11 @@ import type { ObjectType } from "pema";
 export type { Module };
 declare const base_schema: ObjectType<import("pema").NormalizeSchemaObject<{
     readonly extensions: import("pema").OptionalType<import("pema").ArrayType<import("pema").StringType>>;
-    readonly spa: import("pema").DefaultType<import("pema").BooleanType, true>;
+    readonly csr: import("pema").DefaultType<import("pema").BooleanType, true>;
     readonly ssr: import("pema").DefaultType<import("pema").BooleanType, true>;
 }>, {
     extensions: string[] | undefined;
-    spa: boolean;
+    csr: boolean;
     ssr: boolean;
 }>;
 type C = typeof base_schema.Complement;
@@ -62,11 +62,11 @@ export interface Init<S = ServerView, E extends C = ObjectType<never>> {
 }
 export default function frontend_module<S = ServerView, E extends C = ObjectType<never>>(init: Init<S, E>): (input?: E extends ObjectType<never, never> ? {
     extensions?: string[] | undefined;
-    spa?: boolean | undefined;
+    csr?: boolean | undefined;
     ssr?: boolean | undefined;
 } | undefined : Unpack<({
     extensions?: string[] | undefined;
-    spa?: boolean | undefined;
+    csr?: boolean | undefined;
     ssr?: boolean | undefined;
 } | undefined) & E["input"]>) => Module;
 //# sourceMappingURL=frontend.d.ts.map

package/lib/private/frontend.js

@@ -4,11 +4,11 @@ import location from "#location";
 import hash from "@rcompat/crypto/hash";
 import fn from "@rcompat/fn";
 import fs from "@rcompat/fs";
-import { MIME, Status } from "@rcompat/http";
+import http from "@rcompat/http";
 import p from "pema";
 const base_schema = p({
     extensions: p.array(p.string).optional(),
-    spa: p.boolean.default(true),
+    csr: p.boolean.default(true),
     ssr: p.boolean.default(true),
 });
 export default function frontend_module(init) {
@@ -24,7 +24,7 @@ export default function frontend_module(init) {
     }
     return (input) => {
         const options = schema.parse(input);
-        const spa = options.spa;
+        const csr = options.csr;
         const extensions = options.extensions ?? init.extensions;
         let mode = "development";
         function ssr() {
@@ -50,12 +50,15 @@ export default function frontend_module(init) {
                 }
                 return { body, head, headers };
             }
+            const interactive = !ssr() || csr;
+            if (!interactive)
+                return { body, head, headers };
             const app_asset = app.assets.find(asset => asset.src?.includes("app") && asset.src.endsWith(".js"));
             if (app_asset === undefined)
                 throw E.frontend_missing_app_js();
             const app_script = `<script type="module" src="${app_asset.src}"></script>`;
             const props = JSON.stringify({ frontend: init.name, ...client });
-            const hydrated = await inline(props, MIME.APPLICATION_JSON, "hydration");
+            const hydrated = await inline(props, http.MIME.APPLICATION_JSON, "hydration");
             const script_src = [hydrated.integrity];
             return {
                 body,
@@ -81,21 +84,21 @@ export default function frontend_module(init) {
                     : { props, request: $request };
                 const client = {
                     view: init.layouts ? "root" : await normalize(view),
-                    spa: spa,
+                    csr,
                     ssr: ssr(),
                     mode: app.mode,
                     ...$props,
                 };
-                if (spa && request.headers.try("Accept") === MIME.APPLICATION_JSON) {
+                if (csr && request.headers.try("Accept") === http.MIME.APPLICATION_JSON) {
                     const json_body = JSON.stringify(client);
                     return new Response(json_body, {
                         headers: {
                             ...app.headers(),
-                            "Content-Type": MIME.APPLICATION_JSON,
+                            "Content-Type": http.MIME.APPLICATION_JSON,
                             "Content-Length": String(app.body_length(json_body)),
                             "Cache-Control": "no-store",
                         },
-                        status: options.status ?? Status.OK,
+                        status: options.status ?? http.Status.OK,
                     });
                 }
                 if (!ssr()) {

package/lib/private/i18n/errors.d.ts

@@ -10,7 +10,13 @@ declare const errors: {
     unit_not_supported: typeof unit_not_supported;
     no_dots_catalog_keys: typeof no_dots_catalog_keys;
 };
+export declare const Code: {
+    at_least_one_locale: "at_least_one_locale";
+    missing_default_locale: "missing_default_locale";
+    unused_default_locale: "unused_default_locale";
+    unit_not_supported: "unit_not_supported";
+    no_dots_catalog_keys: "no_dots_catalog_keys";
+};
 export type Code = keyof typeof errors;
-export declare const Code: { [K in Code]: K; };
 export default errors;
 //# sourceMappingURL=errors.d.ts.map

package/lib/private/i18n/errors.js

@@ -22,6 +22,6 @@ const errors = error.coded({
     unit_not_supported,
     no_dots_catalog_keys,
 });
-export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
+export const Code = error.names(errors);
 export default errors;
 //# sourceMappingURL=errors.js.map

package/lib/private/i18n/index/types.d.ts

@@ -7,7 +7,7 @@ type EntryOf<Body extends string> = Body extends `${infer Name}:${infer Spec}` ?
     __name: Body & string;
     __type: string;
 };
-export type EntriesOf<S extends string> = string extends S ? never : S extends `${infer _}{${infer Body}}${infer Rest}` ? EntryOf<Body> | EntriesOf<Rest> : never;
+export type EntriesOf<S extends string> = string extends S ? never : S extends `${infer _}{{${infer _}}}${infer Rest}` ? EntriesOf<Rest> : S extends `${infer _}{${infer Body}}${infer Rest}` ? EntryOf<Body> | EntriesOf<Rest> : never;
 export type ParamsFromEntries<E> = [
     E
 ] extends [never] ? Dict : {

package/lib/private/i18n/locale.d.ts

@@ -6,6 +6,6 @@ type EnforceNoDots<T, D extends number = 6> = [
 ] extends [never] ? T : T extends string ? T : T extends readonly (infer E)[] ? readonly EnforceNoDots<E, Prev[D]>[] : T extends object ? {
     [K in keyof T]: K extends string ? K extends `${string}.${string}` ? DotKeyMessage<K> : EnforceNoDots<T[K], Prev[D]> : EnforceNoDots<T[K], Prev[D]>;
 } : T;
-export default function locale<const M extends Catalog>(messages: EnforceNoDots<M>): M;
+export default function locale<const M>(messages: EnforceNoDots<M> & Catalog): M;
 export {};
 //# sourceMappingURL=locale.d.ts.map