@fuzdev/fuz_app 0.135.0 → 0.137.0

package/dist/cli/help.js

@@ -5,10 +5,87 @@
  * once with `create_help` and get back `generate_main_help`,
  * `generate_command_help`, and `get_help_text`.
  *
+ * Schemas are `@fuzdev/fuz_schema` object schemas, the ones `parse_command_args`
+ * and `create_extract_global_flags` take, read with fuz_schema's `introspect.ts`:
+ * each entry's `description` and `aliases` metadata, its default, and its type
+ * as `format_schema_type` renders it.
+ *
  * @module
  */
-import { zod_to_schema_properties, zod_format_value } from '@fuzdev/fuz_util/zod.ts';
+import { format_schema_type, get_schema_fields, get_schema_meta } from '@fuzdev/fuz_schema/introspect.ts';
 import { colors } from './util.js';
+/**
+ * Read the args of an object schema for help output, in order.
+ *
+ * An entry whose `no-` negation is also an entry is left out, so a pair like
+ * `color` and `no-color` is shown once, as `--no-color`.
+ *
+ * @param schema - fuz_schema object schema
+ * @returns the args, none when `schema` is not an object schema
+ */
+export const to_help_arg_properties = (schema) => {
+    const fields = get_schema_fields(schema);
+    const names = new Set(fields.map((f) => f.name));
+    const properties = [];
+    for (const field of fields) {
+        if (names.has('no-' + field.name))
+            continue;
+        properties.push({
+            name: field.name,
+            type: format_schema_type(field.schema),
+            description: field.description ?? '',
+            default: to_field_default(field),
+            aliases: get_schema_meta(field.schema, 'aliases') ?? []
+        });
+    }
+    return properties;
+};
+// the default a field's help shows: a `with_default_fn`'s is made by calling its `make`,
+// as each parse that fills the key in does, found by walking the layers `get_schema_fields`
+// reads, whose first `optional` or default it is when `default_computed`
+const to_field_default = (field) => {
+    if (!field.default_computed)
+        return field.default;
+    let layer = field.schema;
+    for (;;) {
+        switch (layer.kind) {
+            case 'with_default_fn':
+                return layer.def.make();
+            case 'optional':
+            case 'nullable':
+            case 'with_default':
+                layer = layer.def.schema;
+                break;
+            case 'pipe':
+                layer = layer.def[0];
+                break;
+            case 'lazy':
+                layer = layer.def();
+                break;
+            default:
+                return undefined;
+        }
+    }
+};
+/**
+ * Format a default value for display, `''` for none.
+ *
+ * Strings and arrays are written as JSON, as the type column writes a string literal.
+ *
+ * @param value - the default
+ * @returns display text
+ */
+export const format_arg_default = (value) => {
+    if (value === undefined)
+        return '';
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string' || typeof value === 'object')
+        return JSON.stringify(value);
+    if (typeof value === 'boolean' || typeof value === 'number')
+        return String(value);
+    return '';
+};
 /**
  * Get maximum length from array.
  *
@@ -50,7 +127,7 @@ export const create_help = (options) => {
         ? colors
         : { green: '', yellow: '', blue: '', red: '', cyan: '', dim: '', bold: '', reset: '' };
     const generate_global_options = () => {
-        const properties = zod_to_schema_properties(options.global_args_schema);
+        const properties = to_help_arg_properties(options.global_args_schema);
         const max_width = to_max_length(properties, (p) => `  ${format_arg_name(p)}`);
         return properties.map((prop) => {
             const name = format_arg_name(prop);
@@ -65,7 +142,7 @@ export const create_help = (options) => {
         lines.push(`${c.yellow}Usage${c.reset}: ${meta.usage}`);
         lines.push('');
         if (meta.schema) {
-            const properties = zod_to_schema_properties(meta.schema);
+            const properties = to_help_arg_properties(meta.schema);
             const flag_props = properties.filter((p) => p.name !== '_');
             const positional_prop = properties.find((p) => p.name === '_');
             if (positional_prop?.description) {
@@ -79,7 +156,7 @@ export const create_help = (options) => {
                 for (const prop of flag_props) {
                     const name = format_arg_name(prop).padEnd(longest_name);
                     const type = prop.type.padEnd(longest_type);
-                    const def = zod_format_value(prop.default);
+                    const def = format_arg_default(prop.default);
                     const desc = prop.description || '';
                     const default_str = def ? ` (default: ${def})` : '';
                     lines.push(`  ${name}  ${type}  ${desc}${default_str}`);

package/dist/env/load.d.ts

@@ -35,7 +35,7 @@ export declare class EnvValidationError extends Error {
  * `error.all_undefined` before calling this.
  *
  * @param error - the env validation error
- * @param label - optional prefix for log lines (e.g., 'zap daemon', 'env')
+ * @param label - optional prefix for log lines (e.g., 'server', 'env')
  */
 export declare const log_env_validation_error: (error: EnvValidationError, label?: string) => void;
 /**

package/dist/env/load.js

@@ -42,7 +42,7 @@ export class EnvValidationError extends Error {
  * `error.all_undefined` before calling this.
  *
  * @param error - the env validation error
- * @param label - optional prefix for log lines (e.g., 'zap daemon', 'env')
+ * @param label - optional prefix for log lines (e.g., 'server', 'env')
  */
 export const log_env_validation_error = (error, label) => {
     const prefix = label ? `[${label}] ` : '';

package/dist/http/CLAUDE.md

@@ -19,7 +19,7 @@ effects, see ../../../docs/architecture.md.
 - `http/error_schemas.ts` — `ERROR_*` constants, standard error shapes, `derive_error_schemas`.
 - `http/schema_helpers.ts` — shared Zod introspection (null/void/strict/surface/merge/middleware-applies) + `to_void_params` / `to_input_params` / `safe_parse_dropping_unknown_keys`.
 - `http/middleware_spec.ts` — `MiddlewareSpec` interface.
-- `http/body_limit.ts` — `create_body_limit_middleware(max_size)`: the `413` body cap `create_app_server` mounts. Refuses on `Content-Length` without reading `c.req.raw.body` and answers `Connection: close` — `413` past the cap, `400` `ERROR_INVALID_CONTENT_LENGTH` when the value is not a plain run of ASCII digits (a length the cap cannot read, which Hono's `bodyLimit` would pass uncounted) — else falls through to Hono's streaming `bodyLimit` (no `Content-Length`, or one beside `Transfer-Encoding`; that `413` carries no `Connection: close`). Mounted with `app.use`, not as a `MiddlewareSpec`, so neither status appears in a route's merged error schemas. After the header `413` Node closes at once (the header is what makes `@hono/node-server` do so), Deno closes once the declared body has arrived, and Bun keeps the connection and serves the next request (../../../docs/security.md §Body Size Limiting).
+- `http/body_limit.ts` — `create_body_limit_middleware(max_size)`: the `413` body cap `create_app_server` mounts. Refuses on `Content-Length` without reading `c.req.raw.body` and answers `Connection: close` — `413` past the cap, `400` `ERROR_INVALID_CONTENT_LENGTH` when the value is not a plain run of ASCII digits (a length the cap cannot read, which Hono's `bodyLimit` would pass uncounted) — else falls through to Hono's `bodyLimit` (no `Content-Length`, or one beside `Transfer-Encoding`), which reads the body into memory up to the cap before the next middleware runs, so its `413` — no `Connection: close` — also precedes origin and auth. Mounted with `app.use`, not as a `MiddlewareSpec`, so neither status appears in a route's merged error schemas. After the header `413` Node and Bun close at once (the header is what makes them — Bun 1.4.3 is the tested floor, an older Bun kept the connection and served the next request) and Deno closes once the declared body has arrived (../../../docs/security.md §Body Size Limiting).
 - `http/surface.ts` — `AppSurface`, `AppSurfaceSpec`, `generate_app_surface`, diagnostics.
 - `http/surface_query.ts` — pure filters/groupings over `AppSurface`.
 - `http/proxy.ts` — trusted-proxy middleware, CIDR parsing, rightmost-first XFF resolution. Pulls `hono/utils/ipaddr` for CIDR matching.

package/dist/http/auth_shape.d.ts

@@ -134,33 +134,6 @@ export declare const RouteAuth: z.ZodObject<{
     }>;
     roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
     credential_types: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    /**
-     * The capability a **narrowed** api token's scope must admit to reach this
-     * route, in the `<section>:<id>` vocabulary a denial reports back as
-     * `required_scope`:
-     *
-     * - `surface:<name>` — a non-RPC surface, refused to every narrowed token
-     *   whatever its method list says (token scoping's rule that a narrowed
-     *   token is RPC-only). `surface:audit_stream`, `surface:fact_bare`, and
-     *   `surface:app_surface` are the spine's route-spec ones; a consumer names
-     *   its own without registering it.
-     * - `rpc:<method>` — one action method, refused unless the token lists it.
-     *   What a route bridged from an `ActionSpec` declares: it carries the
-     *   method's identity but never reaches the dispatcher's per-method gate.
-     *
-     * Declaring it makes the guard resolver mount the refusal ahead of the role
-     * gate, instead of the route hand-rolling the check in its handler (which
-     * the auth phase has already role-gated by then, so a narrowed token whose
-     * account lacks the role would be told about the role rather than about the
-     * scope).
-     *
-     * Opt-in rather than blanket: the account REST routes cross no boundary, and
-     * the RPC endpoint runs its own per-method check inside the dispatcher — and
-     * both are route specs too.
-     *
-     * Typed as a plain string here to keep `http/` from importing `auth/`; the
-     * resolver parses it at registration and throws on a malformed one.
-     */
     required_scope: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type RouteAuth = z.infer<typeof RouteAuth>;

package/dist/http/auth_shape.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth_shape.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/auth_shape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,WAAW,6DAGtB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,SAGtD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa;;;;EAA2C,CAAC;AACtE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;IAMpB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;;kBAyCF,CAAC;AACJ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAUlD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,SAAS,KAAG,OACA,CAAC;AAElD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,KAAG,OAAgC,CAAC;AAE/E;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,SAAS,KAAG,OAAkC,CAAC;AAEnF,wEAAwE;AACxE,eAAO,MAAM,YAAY,GAAI,MAAM,SAAS,KAAG,OAA+B,CAAC;AAE/E,8FAA8F;AAC9F,eAAO,MAAM,wBAAwB,GAAI,MAAM,SAAS,KAAG,OAC3B,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,SAAS,KAAG,OACQ,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B,GAAI,MAAM,SAAS,KAAG,OACwB,CAAC;AAYvF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,OAIhE,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,sCAAsC,GAClD,MAAM,SAAS,EACf,OAAO,WAAW,EAClB,SAAS,MAAM,KACb,IAmBF,CAAC"}
+{"version":3,"file":"auth_shape.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/auth_shape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,WAAW,6DAGtB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,SAGtD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa;;;;EAA2C,CAAC;AACtE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;kBAyEnB,CAAC;AACJ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAUlD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,SAAS,KAAG,OACA,CAAC;AAElD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,KAAG,OAAgC,CAAC;AAE/E;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,SAAS,KAAG,OAAkC,CAAC;AAEnF,wEAAwE;AACxE,eAAO,MAAM,YAAY,GAAI,MAAM,SAAS,KAAG,OAA+B,CAAC;AAE/E,8FAA8F;AAC9F,eAAO,MAAM,wBAAwB,GAAI,MAAM,SAAS,KAAG,OAC3B,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,SAAS,KAAG,OACQ,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B,GAAI,MAAM,SAAS,KAAG,OACwB,CAAC;AAYvF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,OAIhE,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,sCAAsC,GAClD,MAAM,SAAS,EACf,OAAO,WAAW,EAClB,SAAS,MAAM,KACb,IAmBF,CAAC"}

package/dist/http/body_limit.d.ts

@@ -11,25 +11,36 @@
  *   The runtimes' HTTP parsers answer their own bodiless `400` to most of
  *   these before the application sees them, so this branch is defense in
  *   depth where they do and the refusal where they do not: Node's refuses
- *   them all; Deno hands over a repeated equal header as one combined value
- *   (`50, 50`); Bun hands over an empty value and a repeated header, equal or
- *   differing (`5, 50`), framing the body on the first (observed on Node
- *   24.14.1, Deno 2.8.3, Bun 1.3.11). The Rust spine's parser (hyper) refuses
- *   a malformed value and differing repeats, and accepts an equal repeat as
- *   the one value.
+ *   them all; Deno and Bun hand over a repeated equal header as one combined
+ *   value (`50, 50`) and refuse the rest (observed on Node 24.14.1, Deno
+ *   2.8.3, Bun 1.4.3). The Rust spine's parser (hyper) refuses a malformed
+ *   value and differing repeats, and accepts an equal repeat as the one
+ *   value.
  * - A request whose `Content-Length` exceeds the cap is refused with `413`
  *   `{error: 'payload_too_large'}`, whatever its method. A digit run of any
  *   length compares as a number, so one too long to represent exactly is over
- *   the cap, never unreadable.
+ *   the cap, never unreadable. Over a socket that branch is reached on Node
+ *   and Deno, whose parsers hand over any length below 2^64 and refuse a
+ *   longer one with their own `400`. `Bun.serve` hands none over: with its
+ *   default options it answers a length past 128 MiB with its own `413`, and
+ *   one of 2^63 - 1 or more with its own `400` (observed on Node 24.14.1,
+ *   Deno 2.8.3, Bun 1.4.3).
  * - Both refusals answer on the header alone — without touching
  *   `c.req.raw.body` — and carry `Connection: close`.
  * - A request with a well-formed `Content-Length` beside `Transfer-Encoding`,
- *   or with no `Content-Length`, falls through to `bodyLimit`'s streaming
- *   count: with `Transfer-Encoding` the declared length does not frame the
- *   body, so the bytes that arrive are what is measured. That `413` is sent
- *   once more than the cap has been read and carries no `Connection: close`.
+ *   or with no `Content-Length`, falls through to `bodyLimit`, which measures
+ *   the bytes that arrive: with `Transfer-Encoding` the declared length does
+ *   not frame the body. `bodyLimit` reads the body into memory, up to the
+ *   cap, **before** the next middleware runs, so that `413` — sent once more
+ *   than the cap has been read, with no `Connection: close` — also comes
+ *   ahead of the origin check, auth and the handler. The Rust spine counts
+ *   such a body as its handler reads it instead, so there a refusal made on
+ *   the headers answers first; which status an over-cap body with no declared
+ *   length gets when another refusal also applies is implementation-defined
+ *   across the two (`docs/security.md` §"Body Size Limiting").
  *   The Node, Deno and Bun parsers refuse a request carrying both headers
- *   with their own `400`; hyper accepts one and frames its body as chunked.
+ *   with their own `400`; hyper accepts one, drops its `Content-Length`,
+ *   frames the body as chunked, and closes the connection after the response.
  * - A well-formed `Content-Length` within the cap is trusted to frame the
  *   body, as the runtime's HTTP parser enforces.
  *
@@ -45,8 +56,10 @@
  *   connection open while a client withholds it; a request pipelined behind
  *   the body is not served. Neither the header nor what the handler does with
  *   the body changes that (observed on Deno 2.8.3).
- * - **Bun** keeps the connection, skips the declared body, and serves the
- *   next request on it (observed on Bun 1.3.11).
+ * - **Bun** closes at once, the body unread, honouring the header. Bun 1.4.3
+ *   is the tested floor: an older Bun kept the connection after the `413` and
+ *   served the next request (correctly framed), so run Bun at the floor or
+ *   later.
  *
  * @module
  */

package/dist/http/body_limit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"body_limit.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/body_limit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAQ9C;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,GAAI,UAAU,MAAM,KAAG,iBAwB/D,CAAC"}
+{"version":3,"file":"body_limit.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/body_limit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAQ9C;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,GAAI,UAAU,MAAM,KAAG,iBAwB/D,CAAC"}

package/dist/http/body_limit.js

@@ -11,25 +11,36 @@
  *   The runtimes' HTTP parsers answer their own bodiless `400` to most of
  *   these before the application sees them, so this branch is defense in
  *   depth where they do and the refusal where they do not: Node's refuses
- *   them all; Deno hands over a repeated equal header as one combined value
- *   (`50, 50`); Bun hands over an empty value and a repeated header, equal or
- *   differing (`5, 50`), framing the body on the first (observed on Node
- *   24.14.1, Deno 2.8.3, Bun 1.3.11). The Rust spine's parser (hyper) refuses
- *   a malformed value and differing repeats, and accepts an equal repeat as
- *   the one value.
+ *   them all; Deno and Bun hand over a repeated equal header as one combined
+ *   value (`50, 50`) and refuse the rest (observed on Node 24.14.1, Deno
+ *   2.8.3, Bun 1.4.3). The Rust spine's parser (hyper) refuses a malformed
+ *   value and differing repeats, and accepts an equal repeat as the one
+ *   value.
  * - A request whose `Content-Length` exceeds the cap is refused with `413`
  *   `{error: 'payload_too_large'}`, whatever its method. A digit run of any
  *   length compares as a number, so one too long to represent exactly is over
- *   the cap, never unreadable.
+ *   the cap, never unreadable. Over a socket that branch is reached on Node
+ *   and Deno, whose parsers hand over any length below 2^64 and refuse a
+ *   longer one with their own `400`. `Bun.serve` hands none over: with its
+ *   default options it answers a length past 128 MiB with its own `413`, and
+ *   one of 2^63 - 1 or more with its own `400` (observed on Node 24.14.1,
+ *   Deno 2.8.3, Bun 1.4.3).
  * - Both refusals answer on the header alone — without touching
  *   `c.req.raw.body` — and carry `Connection: close`.
  * - A request with a well-formed `Content-Length` beside `Transfer-Encoding`,
- *   or with no `Content-Length`, falls through to `bodyLimit`'s streaming
- *   count: with `Transfer-Encoding` the declared length does not frame the
- *   body, so the bytes that arrive are what is measured. That `413` is sent
- *   once more than the cap has been read and carries no `Connection: close`.
+ *   or with no `Content-Length`, falls through to `bodyLimit`, which measures
+ *   the bytes that arrive: with `Transfer-Encoding` the declared length does
+ *   not frame the body. `bodyLimit` reads the body into memory, up to the
+ *   cap, **before** the next middleware runs, so that `413` — sent once more
+ *   than the cap has been read, with no `Connection: close` — also comes
+ *   ahead of the origin check, auth and the handler. The Rust spine counts
+ *   such a body as its handler reads it instead, so there a refusal made on
+ *   the headers answers first; which status an over-cap body with no declared
+ *   length gets when another refusal also applies is implementation-defined
+ *   across the two (`docs/security.md` §"Body Size Limiting").
  *   The Node, Deno and Bun parsers refuse a request carrying both headers
- *   with their own `400`; hyper accepts one and frames its body as chunked.
+ *   with their own `400`; hyper accepts one, drops its `Content-Length`,
+ *   frames the body as chunked, and closes the connection after the response.
  * - A well-formed `Content-Length` within the cap is trusted to frame the
  *   body, as the runtime's HTTP parser enforces.
  *
@@ -45,8 +56,10 @@
  *   connection open while a client withholds it; a request pipelined behind
  *   the body is not served. Neither the header nor what the handler does with
  *   the body changes that (observed on Deno 2.8.3).
- * - **Bun** keeps the connection, skips the declared body, and serves the
- *   next request on it (observed on Bun 1.3.11).
+ * - **Bun** closes at once, the body unread, honouring the header. Bun 1.4.3
+ *   is the tested floor: an older Bun kept the connection after the `413` and
+ *   served the next request (correctly framed), so run Bun at the floor or
+ *   later.
  *
  * @module
  */
@@ -77,8 +90,8 @@ export const create_body_limit_middleware = (max_size) => {
             // still a huge number (or `Infinity`), so it compares as over the cap
             if (!c.req.header('transfer-encoding') && Number(content_length) > max_size) {
                 // refused on the header alone, the body untouched; `Connection: close`
-                // makes `@hono/node-server` close at once instead of holding the
-                // connection or serving the request behind the body
+                // makes `@hono/node-server` and Bun close at once instead of holding
+                // the connection or serving the request behind the body
                 return c.json({ error: ERROR_PAYLOAD_TOO_LARGE }, 413, { connection: 'close' });
             }
         }

package/dist/http/db_routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db_routes.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/db_routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAEnD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAqC,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAiBpF;;GAEG;AACH,MAAM,WAAW,SAAS;IACzB,UAAU,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,WAAW,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,sDAAsD;AACtD,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAC/C,sDAAsD;AACtD,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAElD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC,MAAM,CAKrD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC,MAAM,CAKrD,CAAC;AAEH;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC3B;;;;;;;;OAQG;IACH,KAAK,EAAE;QACN,IAAI,EAAE,CACL,GAAG,EAAE;YACJ,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;YACtC,mBAAmB,EAAE,KAAK,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;SACvD,EACD,KAAK,EAAE;YACN,UAAU,EAAE,qBAAqB,CAAC;YAClC,UAAU,EAAE,IAAI,GAAG,IAAI,CAAC;YACxB,EAAE,EAAE,MAAM,CAAC;YACX,QAAQ,EAAE;gBAAE,KAAK,EAAE,MAAM,CAAC;gBAAC,SAAS,EAAE,MAAM,CAAC;gBAAC,EAAE,EAAE,MAAM,CAAA;aAAE,CAAC;SAC3D,KACG,IAAI,CAAC;KACV,CAAC;CACF;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,gBAAgB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC,8EAA8E;IAC9E,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3D,+EAA+E;IAC/E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,oBAAoB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC7C;AA2CD;;GAEG;AACH,eAAO,MAAM,qBAAqB,GACjC,MAAM,WAAW,EACjB,SAAS,cAAc,KACrB,KAAK,CAAC,SAAS,CA4XjB,CAAC"}
+{"version":3,"file":"db_routes.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/db_routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAEnD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAqC,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAiBpF;;GAEG;AACH,MAAM,WAAW,SAAS;IACzB,UAAU,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,WAAW,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,sDAAsD;AACtD,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAC/C,sDAAsD;AACtD,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAElD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC,MAAM,CAKrD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC,MAAM,CAKrD,CAAC;AAEH;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC3B;;;;;;;;OAQG;IACH,KAAK,EAAE;QACN,IAAI,EAAE,CACL,GAAG,EAAE;YACJ,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;YACtC,mBAAmB,EAAE,KAAK,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;SACvD,EACD,KAAK,EAAE;YACN,UAAU,EAAE,qBAAqB,CAAC;YAClC,UAAU,EAAE,IAAI,GAAG,IAAI,CAAC;YACxB,EAAE,EAAE,MAAM,CAAC;YACX,QAAQ,EAAE;gBAAE,KAAK,EAAE,MAAM,CAAC;gBAAC,SAAS,EAAE,MAAM,CAAC;gBAAC,EAAE,EAAE,MAAM,CAAA;aAAE,CAAC;SAC3D,KACG,IAAI,CAAC;KACV,CAAC;CACF;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,gBAAgB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC,8EAA8E;IAC9E,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3D,+EAA+E;IAC/E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,oBAAoB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC7C;AA2CD;;GAEG;AACH,eAAO,MAAM,qBAAqB,GACjC,MAAM,WAAW,EACjB,SAAS,cAAc,KACrB,KAAK,CAAC,SAAS,CA8XjB,CAAC"}

package/dist/http/db_routes.js

@@ -424,9 +424,11 @@ export const create_db_route_specs = (deps, options) => {
                         return c.json({ error: ERROR_ROW_NOT_FOUND }, 404);
                     }
                     // 23503 foreign_key_violation / 23001 restrict_violation — the
-                    // same referencing-row refusal: PG 18+ raises 23001 for `ON
-                    // DELETE RESTRICT` constraints where PG ≤17 raises 23503 for
-                    // both.
+                    // same referencing-row refusal. Which one depends on the
+                    // constraint: `ON DELETE RESTRICT` raises 23001 on PG 18, PGlite
+                    // and pglet (23503 on PG ≤17), and `NO ACTION` — the default,
+                    // when the constraint names no action — raises 23503 on all of
+                    // them.
                     if (code === '23503' || code === '23001') {
                         const pg_err = err;
                         log?.warn('Foreign key violation:', pg_err.detail, pg_err.constraint);

package/dist/primitive_schemas.d.ts

@@ -1,6 +1,6 @@
 /**
- * Reusable validator-schema primitives — `Username`, `UsernameProvided`,
- * `Email`. Lives at the top level (not inside `auth/` or `http/`) because
+ * Reusable validator-schema primitives — `bounded_string`, `Username`,
+ * `UsernameProvided`, `Email`. Lives at the top level (not inside `auth/` or `http/`) because
  * these shapes don't depend on or imply any domain — accounts hold a
  * username and email, but invites, password resets, future cell-sharing,
  * and other surfaces all reach for the same primitives without going
@@ -15,11 +15,45 @@
  * @module
  */
 import { z } from 'zod';
+/** Length bounds for `bounded_string`, in UTF-16 code units. */
+export interface BoundedStringOptions {
+    /** Shortest string admitted. Omit for no lower bound. */
+    min?: number;
+    /** Longest string admitted. */
+    max: number;
+    /** Message for the over-`max` issue, in place of Zod's default. */
+    max_message?: string;
+}
+/**
+ * A string schema whose length is bounded in UTF-16 code units — what
+ * `String.length` measures, and what the Rust spine counts
+ * (`encode_utf16().count()`), so an astral-plane character costs two on both.
+ * Every `.min()` / `.max()` length bound on a wire string in the package is
+ * built here, bar a bare `.min(1)`, which reads the same in either count.
+ *
+ * Zod's `.min()` / `.max()` alone don't pin the unit: depending on the
+ * installed Zod they count code units or Unicode code points, and the peer
+ * range admits both. The schema still carries them — they are what puts
+ * `minLength` / `maxLength` in the generated JSON Schema — and a check beside
+ * them settles the verdict on `String.length`: it adds the over-`max` or
+ * under-`min` issue when Zod raised none, and withdraws one Zod raised for a
+ * string that is within the bound in units. The issue it adds has the fields
+ * of Zod's own and, like Zod's, lets the checks chained after it run, so a
+ * refusal reads the same whichever count Zod used.
+ *
+ * Returns a plain `ZodString`, so format checks, `.brand()`, `.nullish()` and
+ * `.meta()` chain as usual. Don't chain a further `.min()` / `.max()` — pass
+ * the bound here.
+ *
+ * @param options - the bounds, in UTF-16 code units
+ * @returns the bounded string schema
+ */
+export declare const bounded_string: ({ min, max, max_message }: BoundedStringOptions) => z.ZodString;
 /** Minimum username length (must have start + middle + end characters). */
 export declare const USERNAME_LENGTH_MIN = 3;
-/** Maximum username length (matches GitHub's limit). */
+/** Maximum username length (matches GitHub's limit). The grammar is ASCII, so units and characters agree. */
 export declare const USERNAME_LENGTH_MAX = 39;
-/** Maximum length for username input on login/lookup — more permissive than `USERNAME_LENGTH_MAX` for forward-compatibility if the creation limit is raised. */
+/** Maximum length for username input on login/lookup, in UTF-16 code units, measured before trimming — more permissive than `USERNAME_LENGTH_MAX` for forward-compatibility if the creation limit is raised. */
 export declare const USERNAME_PROVIDED_LENGTH_MAX = 255;
 /**
  * Username for account creation — starts with letter, alphanumeric/dash/underscore middle, ends with alphanumeric. No @ or . allowed.

package/dist/primitive_schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"primitive_schemas.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/primitive_schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,2EAA2E;AAC3E,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,wDAAwD;AACxD,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,gKAAgK;AAChK,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAEhD;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,wDAKc,CAAC;AACpC,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,wDAKqE,CAAC;AACnG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAqBpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,aAYhB,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC"}
+{"version":3,"file":"primitive_schemas.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/primitive_schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,gEAAgE;AAChE,MAAM,WAAW,oBAAoB;IACpC,yDAAyD;IACzD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc,GAAI,2BAA2B,oBAAoB,KAAG,CAAC,CAAC,SA8ClF,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,6GAA6G;AAC7G,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,gNAAgN;AAChN,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAEhD;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,wDAEc,CAAC;AACpC,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,wDAEqE,CAAC;AACnG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAqBpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,aAYhB,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC"}

package/dist/primitive_schemas.js

@@ -1,6 +1,6 @@
 /**
- * Reusable validator-schema primitives — `Username`, `UsernameProvided`,
- * `Email`. Lives at the top level (not inside `auth/` or `http/`) because
+ * Reusable validator-schema primitives — `bounded_string`, `Username`,
+ * `UsernameProvided`, `Email`. Lives at the top level (not inside `auth/` or `http/`) because
  * these shapes don't depend on or imply any domain — accounts hold a
  * username and email, but invites, password resets, future cell-sharing,
  * and other surfaces all reach for the same primitives without going
@@ -15,12 +15,82 @@
  * @module
  */
 import { z } from 'zod';
-// TODO consider `.brand()` on Username and Email for compile-time safety
+/**
+ * A string schema whose length is bounded in UTF-16 code units — what
+ * `String.length` measures, and what the Rust spine counts
+ * (`encode_utf16().count()`), so an astral-plane character costs two on both.
+ * Every `.min()` / `.max()` length bound on a wire string in the package is
+ * built here, bar a bare `.min(1)`, which reads the same in either count.
+ *
+ * Zod's `.min()` / `.max()` alone don't pin the unit: depending on the
+ * installed Zod they count code units or Unicode code points, and the peer
+ * range admits both. The schema still carries them — they are what puts
+ * `minLength` / `maxLength` in the generated JSON Schema — and a check beside
+ * them settles the verdict on `String.length`: it adds the over-`max` or
+ * under-`min` issue when Zod raised none, and withdraws one Zod raised for a
+ * string that is within the bound in units. The issue it adds has the fields
+ * of Zod's own and, like Zod's, lets the checks chained after it run, so a
+ * refusal reads the same whichever count Zod used.
+ *
+ * Returns a plain `ZodString`, so format checks, `.brand()`, `.nullish()` and
+ * `.meta()` chain as usual. Don't chain a further `.min()` / `.max()` — pass
+ * the bound here.
+ *
+ * @param options - the bounds, in UTF-16 code units
+ * @returns the bounded string schema
+ */
+export const bounded_string = ({ min, max, max_message }) => {
+    let schema = z.string();
+    if (min !== undefined)
+        schema = schema.min(min);
+    schema = max_message === undefined ? schema.max(max) : schema.max(max, max_message);
+    return schema.check((ctx) => {
+        const { length } = ctx.value;
+        const { issues } = ctx;
+        const too_big = issues.findIndex((i) => i.code === 'too_big' && i.origin === 'string' && i.maximum === max);
+        if (length > max) {
+            if (too_big === -1) {
+                issues.push({
+                    origin: 'string',
+                    code: 'too_big',
+                    maximum: max,
+                    inclusive: true,
+                    input: ctx.value,
+                    // as on Zod's own length issues: the checks chained after still run
+                    continue: true,
+                    // `path` ahead of `message`, the key order of Zod's finalized issue
+                    ...(max_message !== undefined && { path: [], message: max_message })
+                });
+            }
+        }
+        else if (too_big !== -1) {
+            issues.splice(too_big, 1);
+        }
+        if (min === undefined)
+            return;
+        const too_small = issues.findIndex((i) => i.code === 'too_small' && i.origin === 'string' && i.minimum === min);
+        if (length < min) {
+            if (too_small === -1) {
+                issues.push({
+                    origin: 'string',
+                    code: 'too_small',
+                    minimum: min,
+                    inclusive: true,
+                    input: ctx.value,
+                    continue: true
+                });
+            }
+        }
+        else if (too_small !== -1) {
+            issues.splice(too_small, 1);
+        }
+    });
+};
 /** Minimum username length (must have start + middle + end characters). */
 export const USERNAME_LENGTH_MIN = 3;
-/** Maximum username length (matches GitHub's limit). */
+/** Maximum username length (matches GitHub's limit). The grammar is ASCII, so units and characters agree. */
 export const USERNAME_LENGTH_MAX = 39;
-/** Maximum length for username input on login/lookup — more permissive than `USERNAME_LENGTH_MAX` for forward-compatibility if the creation limit is raised. */
+/** Maximum length for username input on login/lookup, in UTF-16 code units, measured before trimming — more permissive than `USERNAME_LENGTH_MAX` for forward-compatibility if the creation limit is raised. */
 export const USERNAME_PROVIDED_LENGTH_MAX = 255;
 /**
  * Username for account creation — starts with letter, alphanumeric/dash/underscore middle, ends with alphanumeric. No @ or . allowed.
@@ -32,10 +102,7 @@ export const USERNAME_PROVIDED_LENGTH_MAX = 255;
  * per-caller `trim().toLowerCase()` ritual and keeps the
  * `LOWER(username) = LOWER($1)` lookup contract simple.
  */
-export const Username = z
-    .string()
-    .min(USERNAME_LENGTH_MIN)
-    .max(USERNAME_LENGTH_MAX)
+export const Username = bounded_string({ min: USERNAME_LENGTH_MIN, max: USERNAME_LENGTH_MAX })
     .regex(/^[a-zA-Z][0-9a-zA-Z_-]*[0-9a-zA-Z]$/)
     .transform((s) => s.toLowerCase());
 /**
@@ -53,10 +120,7 @@ export const Username = z
  * input, not a wrong credential. Keeps the Rust spine's
  * `account_login` (which rejects empty-after-trim) in parity.
  */
-export const UsernameProvided = z
-    .string()
-    .min(1)
-    .max(USERNAME_PROVIDED_LENGTH_MAX)
+export const UsernameProvided = bounded_string({ min: 1, max: USERNAME_PROVIDED_LENGTH_MAX })
     .transform((s) => s.trim().toLowerCase())
     .refine((s) => s.length > 0, { message: 'Username must not be empty after trimming whitespace' });
 /**

package/dist/server/x_accel.d.ts

@@ -50,7 +50,6 @@ export declare const validate_facts_internal_location: (config: string, facts_lo
  * an explicit cast, so the factory is the only ordinary construction path.
  */
 export declare const XAccelConfig: z.core.$ZodBranded<z.ZodObject<{
-    /** The validated redirect prefix the serving path prepends (e.g. `/_facts/`). */
     redirect_prefix: z.ZodString;
 }, z.core.$strict>, "XAccelConfig", "out">;
 export type XAccelConfig = z.infer<typeof XAccelConfig>;

package/dist/server/x_accel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x_accel.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/server/x_accel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,0CAA0C;AAC1C,MAAM,WAAW,oBAAoB;IACpC,gEAAgE;IAChE,EAAE,EAAE,OAAO,CAAC;IACZ,iEAAiE;IACjE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACtB;AAuDD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gCAAgC,GAC5C,QAAQ,MAAM,EACd,gBAAgB,MAAM,KACpB,oBAqBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY;IAEvB,iFAAiF;;0CAG5D,CAAC;AACxB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC3C,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;gBACnB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;CAKjC;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,GACjC,iBAAiB,MAAM,EACvB,cAAc,MAAM,KAClB,YAMF,CAAC"}
+{"version":3,"file":"x_accel.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/server/x_accel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,0CAA0C;AAC1C,MAAM,WAAW,oBAAoB;IACpC,gEAAgE;IAChE,EAAE,EAAE,OAAO,CAAC;IACZ,iEAAiE;IACjE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACtB;AAuDD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gCAAgC,GAC5C,QAAQ,MAAM,EACd,gBAAgB,MAAM,KACpB,oBAqBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY;;0CAKF,CAAC;AACxB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC3C,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;gBACnB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;CAKjC;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,GACjC,iBAAiB,MAAM,EACvB,cAAc,MAAM,KAClB,YAMF,CAAC"}