@atcute/xrpc-server 1.0.0 → 2.0.1

package/dist/auth/index.d.ts

@@ -1,3 +1,2 @@
 export * from './jwt-creator.ts';
 export * from './jwt-verifier.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/auth/index.js

@@ -1,3 +1,2 @@
 export * from './jwt-creator.js';
 export * from './jwt-verifier.js';
-//# sourceMappingURL=index.js.map

package/dist/auth/jwt-creator.d.ts

@@ -11,4 +11,3 @@ export interface CreateServiceJwtOptions {
     expiresIn?: number;
 }
 export declare const createServiceJwt: (options: CreateServiceJwtOptions) => Promise<string>;
-//# sourceMappingURL=jwt-creator.d.ts.map

package/dist/auth/jwt-creator.js

@@ -27,4 +27,3 @@ export const createServiceJwt = async (options) => {
 const encodeJwtPortion = (data) => {
     return toBase64Url(encodeUtf8(JSON.stringify(data)));
 };
-//# sourceMappingURL=jwt-creator.js.map

package/dist/auth/jwt-verifier.d.ts

@@ -2,20 +2,17 @@ import { type DidDocumentResolver } from '@atcute/identity-resolver';
 import type { Did, Nsid } from '@atcute/lexicons';
 import type { AtprotoAudience } from '@atcute/lexicons/syntax';
 /**
- * replay-protection store for service JWTs. when configured on a verifier,
- * tokens must carry a `jti` claim and the verifier consults this store to
- * reject duplicates.
+ * replay-protection store for service JWTs. when configured on a verifier, tokens must carry a `jti` claim
+ * and the verifier consults this store to reject duplicates.
  */
 export interface ReplayStore {
     /**
      * record a `(iss, jti)` pair seen now.
      *
-     * @param key issuer + token identifier; implementations decide how to
-     *   encode this into a storage key.
-     * @param ttlSeconds how long the entry must be retained. implementations
-     *   are free to retain it for longer.
-     * @returns `true` if the pair was previously unseen (token is unique),
-     *   `false` if the pair has been recorded before (replay).
+     * @param key issuer + token identifier; implementations decide how to encode this into a storage key.
+     * @param ttlSeconds how long the entry must be retained. implementations are free to retain it for longer.
+     * @returns `true` if the pair was previously unseen (token is unique), `false` if the pair has been
+     *   recorded before (replay).
      */
     check(key: {
         iss: Did;
@@ -24,29 +21,25 @@ export interface ReplayStore {
 }
 export interface ServiceJwtVerifierOptions {
     /**
-     * list of `aud` values accepted by this service; each entry is a bare DID or a DID with
-     * service fragment (e.g. `did:web:x.example#svc`), and incoming tokens must exact-match any entry.
+     * list of `aud` values accepted by this service; each entry is a bare DID or a DID with service fragment
+     * (e.g. `did:web:x.example#svc`), and incoming tokens must exact-match any entry.
      *
-     * pass `null` to skip audience validation (accept any audience). an empty array rejects every
-     * audience, which is useful when a service wants to fail closed until configured.
+     * pass `null` to skip audience validation (accept any audience). an empty array rejects every audience,
+     * which is useful when a service wants to fail closed until configured.
      */
     acceptAudiences: (Did | AtprotoAudience)[] | null;
     resolver: DidDocumentResolver;
     /**
-     * maximum token lifetime window in seconds. rejects tokens whose `exp` is
-     * more than this far in the future or whose `iat` is more than this far in
-     * the past. defaults to 300 (5 minutes), matching atproto convention.
+     * maximum token lifetime window in seconds. rejects tokens whose `exp` is more than this far in the future
+     * or whose `iat` is more than this far in the past. defaults to 300 (5 minutes), matching atproto
+     * convention.
      */
     maxAge?: number;
-    /**
-     * clock-skew leeway in seconds applied to `exp` and `nbf` comparisons.
-     * defaults to 5 seconds.
-     */
+    /** clock-skew leeway in seconds applied to `exp` and `nbf` comparisons. defaults to 5 seconds. */
     clockLeeway?: number;
     /**
-     * optional replay-protection store. when provided, tokens must carry a
-     * `jti` claim and the verifier rejects any `(iss, jti)` the store reports
-     * as previously seen.
+     * optional replay-protection store. when provided, tokens must carry a `jti` claim and the verifier rejects
+     * any `(iss, jti)` the store reports as previously seen.
      */
     replayStore?: ReplayStore;
 }
@@ -69,17 +62,15 @@ export declare class ServiceJwtVerifier {
     replayStore?: ReplayStore;
     constructor(options: ServiceJwtVerifierOptions);
     /**
-     * parse the Authorization header, verify the bearer token, and return the
-     * validated claims. throws {@link AuthRequiredError} with a populated
-     * `WWW-Authenticate: Bearer` challenge on every failure path.
+     * parse the Authorization header, verify the bearer token, and return the validated claims. throws
+     * {@link AuthRequiredError} with a populated `WWW-Authenticate: Bearer` challenge on every failure path.
      *
-     * @param request incoming request; `request.signal` is forwarded to DID
-     *   resolution unless `options.signal` overrides it.
-     * @param options verification options; `lxm` restricts which lexicon
-     *   methods the token is allowed to invoke.
-     * @throws {AuthRequiredError} on missing header, malformed token,
-     *   signature mismatch, audience/lxm rejection, replay, or expiry.
+     * @param request incoming request; `request.signal` is forwarded to DID resolution unless `options.signal`
+     *   overrides it.
+     * @param options verification options; `lxm` restricts which lexicon methods the token is allowed to
+     *   invoke.
+     * @throws {AuthRequiredError} on missing header, malformed token, signature mismatch, audience/lxm
+     *   rejection, replay, or expiry.
      */
     verifyRequest(request: Request, options: VerifyJwtOptions): Promise<VerifiedJwt>;
 }
-//# sourceMappingURL=jwt-verifier.d.ts.map

package/dist/auth/jwt-verifier.js

@@ -21,16 +21,15 @@ export class ServiceJwtVerifier {
         this.replayStore = options.replayStore;
     }
     /**
-     * parse the Authorization header, verify the bearer token, and return the
-     * validated claims. throws {@link AuthRequiredError} with a populated
-     * `WWW-Authenticate: Bearer` challenge on every failure path.
+     * parse the Authorization header, verify the bearer token, and return the validated claims. throws
+     * {@link AuthRequiredError} with a populated `WWW-Authenticate: Bearer` challenge on every failure path.
      *
-     * @param request incoming request; `request.signal` is forwarded to DID
-     *   resolution unless `options.signal` overrides it.
-     * @param options verification options; `lxm` restricts which lexicon
-     *   methods the token is allowed to invoke.
-     * @throws {AuthRequiredError} on missing header, malformed token,
-     *   signature mismatch, audience/lxm rejection, replay, or expiry.
+     * @param request incoming request; `request.signal` is forwarded to DID resolution unless `options.signal`
+     *   overrides it.
+     * @param options verification options; `lxm` restricts which lexicon methods the token is allowed to
+     *   invoke.
+     * @throws {AuthRequiredError} on missing header, malformed token, signature mismatch, audience/lxm
+     *   rejection, replay, or expiry.
      */
     async verifyRequest(request, options) {
         const authorization = request.headers.get('authorization');
@@ -281,4 +280,3 @@ const authError = (err) => {
         wwwAuthenticate: { scheme: 'Bearer', params: { error: err.error } },
     });
 };
-//# sourceMappingURL=jwt-verifier.js.map

package/dist/auth/jwt.d.ts

@@ -25,4 +25,3 @@ export interface ParsedJwt {
     signature: Uint8Array<ArrayBuffer>;
 }
 export declare const parseJwt: (jwtString: string) => Result<ParsedJwt, AuthError>;
-//# sourceMappingURL=jwt.d.ts.map

package/dist/auth/jwt.js

@@ -2,20 +2,17 @@ import { isAtprotoAudience } from '@atcute/identity';
 import { isDid, isNsid } from '@atcute/lexicons/syntax';
 import { fromBase64Url } from '@atcute/multibase';
 import { decodeUtf8From, encodeUtf8 } from '@atcute/uint8array';
-import * as v from '@badrap/valita';
-const didString = v.string().assert(isDid, `must be a did`);
-const audienceString = v
-    .string()
-    .assert((input) => isAtprotoAudience(input) || isDid(input), `must be a did or atproto audience`);
-const nsidString = v.string().assert(isNsid, `must be an nsid`);
-const integer = v.number().assert((input) => input >= 0 && Number.isSafeInteger(input), `must be an integer`);
-const jwtHeader = v.object({
-    typ: v.string().optional(),
+import * as v from 'valibot';
+const didString = v.custom(isDid, `must be a did`);
+const audienceString = v.custom((input) => isAtprotoAudience(input) || isDid(input), `must be a did or atproto audience`);
+const nsidString = v.custom(isNsid, `must be an nsid`);
+const integer = v.pipe(v.number(), v.safeInteger(), v.minValue(0));
+const jwtHeader = v.looseObject({
+    typ: v.optional(v.string()),
     alg: v.string(),
-    kid: v.string().optional(),
+    kid: v.optional(v.string()),
 });
-const jwtPayload = v
-    .object({
+const jwtPayload = v.pipe(v.looseObject({
     /** issuer */
     iss: didString,
     /** target audience; a bare DID or a DID with service fragment (e.g. `did:web:x.example#svc`) */
@@ -23,28 +20,26 @@ const jwtPayload = v
     /** expiration time */
     exp: integer,
     /** creation time */
-    iat: integer.optional(),
+    iat: v.optional(integer),
     /** not-before time */
-    nbf: integer.optional(),
+    nbf: v.optional(integer),
     /** xrpc operation being invoked; required per atproto service auth spec */
     lxm: nsidString,
     /** unique identifier */
-    jti: v.string().optional(),
-})
-    .assert(({ iat, exp }) => iat === undefined || exp > iat, {
-    message: `expiry time must be greater than issued time`,
-    path: ['exp'],
-});
+    jti: v.optional(v.string()),
+}), v.forward(v.check(({ iat, exp }) => iat === undefined || exp > iat, `expiry time must be greater than issued time`), ['exp']));
 const readJwtPortion = (schema, input) => {
     try {
         const raw = decodeUtf8From(fromBase64Url(input));
         const json = JSON.parse(raw);
-        const result = schema.try(json, { mode: 'passthrough' });
-        if (result.ok) {
-            return result;
+        const result = v.safeParse(schema, json);
+        if (result.success) {
+            return { ok: true, value: result.output };
         }
     }
-    catch { }
+    catch {
+        /* empty */
+    }
     return {
         ok: false,
         error: {
@@ -57,7 +52,9 @@ const readJwtSignature = (input) => {
     try {
         return { ok: true, value: fromBase64Url(input) };
     }
-    catch { }
+    catch {
+        /* empty */
+    }
     return {
         ok: false,
         error: {
@@ -100,4 +97,3 @@ export const parseJwt = (jwtString) => {
         },
     };
 };
-//# sourceMappingURL=jwt.js.map

package/dist/auth/types.d.ts

@@ -2,4 +2,3 @@ export type AuthError = {
     error: string;
     description: string;
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/auth/types.js

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

package/dist/main/index.d.ts

@@ -4,4 +4,3 @@ export * from './xrpc-error.ts';
 export * from './xrpc-handler.ts';
 export type { ProcedureConfig, ProcedureContext, ProcedureHandler, QueryConfig, QueryContext, QueryHandler, SubscriptionConfig, SubscriptionContext, SubscriptionHandler, } from './types/operation.ts';
 export * from './types/websocket.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/main/index.js

@@ -3,4 +3,3 @@ export * from './router.js';
 export * from './xrpc-error.js';
 export * from './xrpc-handler.js';
 export * from './types/websocket.js';
-//# sourceMappingURL=index.js.map

package/dist/main/response.d.ts

@@ -6,4 +6,3 @@ export declare const json: {
     <TData>(data: NoInfer<TData>, init?: ResponseInit): JSONResponse<TData>;
 };
 export {};
-//# sourceMappingURL=response.d.ts.map

package/dist/main/response.js

@@ -1,4 +1,3 @@
 export const json = (data, init) => {
     return Response.json(data, init);
 };
-//# sourceMappingURL=response.js.map

package/dist/main/router.d.ts

@@ -24,24 +24,21 @@ export interface XRPCRouterOptions {
     middlewares?: FetchMiddleware[];
     handleNotFound?: NotFoundHandler;
     /**
-     * optional handler for `/xrpc/_health`. when provided, the router answers
-     * health-check requests by invoking this handler; when absent, the path
-     * falls through to `handleNotFound`. `_health` is not part of the atproto
-     * XRPC spec, so callers opt in explicitly.
+     * optional handler for `/xrpc/_health`. when provided, the router answers health-check requests by invoking
+     * this handler; when absent, the path falls through to `handleNotFound`. `_health` is not part of the
+     * atproto XRPC spec, so callers opt in explicitly.
      */
     handleHealthCheck?: HealthCheckHandler;
     /** translates a thrown error into an HTTP response. */
     handleException?: ExceptionHandler;
     /**
-     * fire-and-forget telemetry hook for unexpected HTTP errors. not invoked for
-     * client-induced errors (aborted requests, `XRPCError` subclasses, thrown
-     * `Response` objects).
+     * fire-and-forget telemetry hook for unexpected HTTP errors. not invoked for client-induced errors (aborted
+     * requests, `XRPCError` subclasses, thrown `Response` objects).
      */
     onError?: ErrorObserver;
     /**
-     * fire-and-forget telemetry hook for unexpected subscription errors. not
-     * invoked for aborted signals or `XRPCSubscriptionError` (which is
-     * translated to an error frame).
+     * fire-and-forget telemetry hook for unexpected subscription errors. not invoked for aborted signals or
+     * `XRPCSubscriptionError` (which is translated to an error frame).
      */
     onSocketError?: SocketErrorObserver;
     websocket?: WebSocketAdapter;
@@ -50,11 +47,7 @@ export declare class XRPCRouter {
     #private;
     fetch: (request: Request) => Promise<Response>;
     constructor({ middlewares, handleException, handleNotFound, handleHealthCheck, onError, onSocketError, websocket, }?: XRPCRouterOptions);
-    /** @deprecated use `addQuery` and `addProcedure` instead */
-    add<TQuery extends XRPCQueryMetadata>(query: TQuery | Namespaced<TQuery>, config: QueryConfig<TQuery>): void;
-    add<TProcedure extends XRPCProcedureMetadata>(procedure: TProcedure | Namespaced<TProcedure>, config: ProcedureConfig<TProcedure>): void;
     addQuery<TQuery extends XRPCQueryMetadata, TConfig extends QueryConfig<TQuery>>(query: TQuery | Namespaced<TQuery>, config: TConfig): void;
     addProcedure<TProcedure extends XRPCProcedureMetadata, TConfig extends ProcedureConfig<TProcedure>>(procedure: TProcedure | Namespaced<TProcedure>, config: TConfig): void;
     addSubscription<TSubscription extends XRPCSubscriptionMetadata, TConfig extends SubscriptionConfig<TSubscription>>(subscription: TSubscription | Namespaced<TSubscription>, config: TConfig): void;
 }
-//# sourceMappingURL=router.d.ts.map

package/dist/main/router.js

@@ -113,17 +113,6 @@ export class XRPCRouter {
             return this.#handleException(err, request);
         }
     }
-    add(operation, config) {
-        const schema = unwrapLxm(operation);
-        switch (schema.type) {
-            case 'xrpc_query': {
-                return this.addQuery(schema, config);
-            }
-            case 'xrpc_procedure': {
-                return this.addProcedure(schema, config);
-            }
-        }
-    }
     addQuery(query, config) {
         const querySchema = unwrapLxm(query);
         const handleParams = querySchema.params ? constructParamsHandler(querySchema.params) : null;
@@ -147,6 +136,7 @@ export class XRPCRouter {
                     signal: request.signal,
                     params: params,
                 };
+                // oxlint-disable-next-line typescript/no-explicit-any
                 const output = await handler(context);
                 if (output instanceof Response) {
                     return output;
@@ -188,6 +178,7 @@ export class XRPCRouter {
                         }
                     }
                     if (inputSchema !== null) {
+                        // oxlint-disable-next-line typescript/no-explicit-any
                         let raw;
                         try {
                             raw = await request.json();
@@ -213,6 +204,7 @@ export class XRPCRouter {
                     params: params,
                     input: input,
                 };
+                // oxlint-disable-next-line typescript/no-explicit-any
                 const output = await handler(context);
                 if (output instanceof Response) {
                     return output;
@@ -301,4 +293,3 @@ export class XRPCRouter {
         };
     }
 }
-//# sourceMappingURL=router.js.map

package/dist/main/types/operation.d.ts

@@ -4,10 +4,9 @@ import type { JSONResponse } from '../response.ts';
 /**
  * untyped variant of {@link QueryContext} / {@link ProcedureContext}.
  *
- * `input` is set only when the lexicon declares a `lex` input body and the
- * request JSON parsed successfully. for blob inputs (and for procedures that
- * declare no input at all) it is `undefined`; handlers that expect a blob
- * should stream from `request.body` directly.
+ * `input` is set only when the lexicon declares a `lex` input body and the request JSON parsed successfully.
+ * for blob inputs (and for procedures that declare no input at all) it is `undefined`; handlers that expect a
+ * blob should stream from `request.body` directly.
  */
 export type UnknownOperationContext = {
     request: Request;
@@ -61,4 +60,3 @@ export type SubscriptionHandler<TSubscription extends XRPCSubscriptionMetadata>
 export type SubscriptionConfig<TSubscription extends XRPCSubscriptionMetadata = XRPCSubscriptionMetadata> = {
     handler: SubscriptionHandler<TSubscription>;
 };
-//# sourceMappingURL=operation.d.ts.map

package/dist/main/types/operation.js

@@ -1,2 +1,2 @@
+// oxlint-disable typescript/no-explicit-any
 export {};
-//# sourceMappingURL=operation.js.map

package/dist/main/types/websocket.d.ts

@@ -3,10 +3,9 @@ export interface WebSocketConnection {
     signal: AbortSignal;
     send(data: Uint8Array): void | Promise<void>;
     /**
-     * backpressure hook invoked by the router after every frame it sends.
-     * adapters that can observe the outgoing send buffer (Node `ws`, Bun, Deno)
-     * should resolve only once the buffer has drained below a healthy threshold.
-     * adapters without that visibility (e.g. Cloudflare Workers) should return
+     * backpressure hook invoked by the router after every frame it sends. adapters that can observe the
+     * outgoing send buffer (Node `ws`, Bun, Deno) should resolve only once the buffer has drained below a
+     * healthy threshold. adapters without that visibility (e.g. Cloudflare Workers) should return
      * synchronously.
      */
     drain(): void | Promise<void>;
@@ -15,4 +14,3 @@ export interface WebSocketConnection {
 export interface WebSocketAdapter {
     upgrade(request: Request, handler: (ws: WebSocketConnection) => Promisable<void>): Promisable<Response | undefined>;
 }
-//# sourceMappingURL=websocket.d.ts.map

package/dist/main/types/websocket.js

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

package/dist/main/utils/frames.d.ts

@@ -2,4 +2,3 @@ export declare const encodeMessageFrame: (body: unknown, type?: string) => Uint8
 export declare const encodeErrorFrame: (error: string, message?: string) => Uint8Array;
 export declare const extractMessageType: (message: unknown, nsid: string) => string | undefined;
 export declare const omitMessageType: (message: unknown) => unknown;
-//# sourceMappingURL=frames.d.ts.map

package/dist/main/utils/frames.js

@@ -42,4 +42,3 @@ export const omitMessageType = (message) => {
     const { $type: _type, ...rest } = obj;
     return rest;
 };
-//# sourceMappingURL=frames.js.map

package/dist/main/utils/middlewares.d.ts

@@ -1,3 +1,2 @@
 export type Middleware<TParams extends any[], TReturn> = (...params: [...TParams, next: (...params: TParams) => TReturn]) => TReturn;
 export declare const createAsyncMiddlewareRunner: <TParams extends any[], TReturn>(middlewares: [...Middleware<TParams, Promise<TReturn>>[], Middleware<TParams, Promise<TReturn>>]) => (...params: TParams) => Promise<TReturn>;
-//# sourceMappingURL=middlewares.d.ts.map

package/dist/main/utils/middlewares.js

@@ -1,5 +1,5 @@
+// oxlint-disable typescript/no-explicit-any
 export const createAsyncMiddlewareRunner = (middlewares) => {
     // prettier-ignore
     return middlewares.reduceRight((next, run) => (...args) => run(...args, next), () => Promise.reject(new Error(`middleware chain exhausted`)));
 };
-//# sourceMappingURL=middlewares.js.map

package/dist/main/utils/namespaced.d.ts

@@ -2,4 +2,3 @@ export type Namespaced<T> = {
     mainSchema: T;
 };
 export declare const unwrapLxm: <T extends object>(schema: T | Namespaced<T>) => T;
-//# sourceMappingURL=namespaced.d.ts.map

package/dist/main/utils/namespaced.js

@@ -1,4 +1,3 @@
 export const unwrapLxm = (schema) => {
     return 'mainSchema' in schema ? schema.mainSchema : schema;
 };
-//# sourceMappingURL=namespaced.js.map

package/dist/main/utils/request-input.d.ts

@@ -3,14 +3,12 @@ import type { Result } from '../../types/misc.ts';
 /**
  * checks whether a request has a meaningful body.
  *
- * Node.js HTTP-to-fetch adapters always provide a `ReadableStream` for
- * `request.body`, even when no body content was sent. this function
- * uses `content-length` to handle that case while still respecting the
- * web `Request` API where `body === null` signals no body.
+ * Node.js HTTP-to-fetch adapters always provide a `ReadableStream` for `request.body`, even when no body
+ * content was sent. this function uses `content-length` to handle that case while still respecting the web
+ * `Request` API where `body === null` signals no body.
  *
  * @param request incoming request to check
  * @returns whether the request has body content
  */
 export declare const hasRequestBody: (request: Request) => boolean;
 export declare const constructMimeValidator: (param: XRPCLexBodyParam | XRPCBlobBodyParam) => ((request: Request) => Result<void, string>) | null;
-//# sourceMappingURL=request-input.d.ts.map

package/dist/main/utils/request-input.js

@@ -1,10 +1,9 @@
 /**
  * checks whether a request has a meaningful body.
  *
- * Node.js HTTP-to-fetch adapters always provide a `ReadableStream` for
- * `request.body`, even when no body content was sent. this function
- * uses `content-length` to handle that case while still respecting the
- * web `Request` API where `body === null` signals no body.
+ * Node.js HTTP-to-fetch adapters always provide a `ReadableStream` for `request.body`, even when no body
+ * content was sent. this function uses `content-length` to handle that case while still respecting the web
+ * `Request` API where `body === null` signals no body.
  *
  * @param request incoming request to check
  * @returns whether the request has body content
@@ -69,4 +68,3 @@ const separatedList = (list, sep) => {
 const escapeRegexp = (input) => {
     return input.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
 };
-//# sourceMappingURL=request-input.js.map

package/dist/main/utils/request-params.d.ts

@@ -3,4 +3,3 @@ import type { Literal } from '../../types/misc.ts';
 type MaybeArray<T> = T | T[];
 export declare const constructParamsHandler: <TSchema extends ObjectSchema>(schema: TSchema) => (searchParams: URLSearchParams) => ValidationResult<Record<string, MaybeArray<Literal>>>;
 export {};
-//# sourceMappingURL=request-params.d.ts.map

package/dist/main/utils/request-params.js

@@ -13,10 +13,12 @@ const unwrapArray = (schema) => {
 };
 const coerceBoolean = (str) => {
     switch (str) {
-        case 'true':
+        case 'true': {
             return true;
-        case 'false':
+        }
+        case 'false': {
             return false;
+        }
     }
     return null;
 };
@@ -77,4 +79,3 @@ const set = (obj, key, value) => {
         obj[key] = value;
     }
 };
-//# sourceMappingURL=request-params.js.map

package/dist/main/utils/response.d.ts

@@ -1,4 +1,3 @@
 import type { Err } from '@atcute/lexicons/validations';
 export declare const invalidRequest: (message: string) => Response;
 export declare const validationError: (kind: 'params' | 'input', err: Err) => Response;
-//# sourceMappingURL=response.d.ts.map

package/dist/main/utils/response.js

@@ -5,4 +5,3 @@ export const validationError = (kind, err) => {
     const message = `invalid ${kind}: ${err.message}`;
     return Response.json({ error: 'InvalidRequest', message: message, 'net.kelinci.atcute.issues': err.issues }, { status: 400 });
 };
-//# sourceMappingURL=response.js.map

package/dist/main/utils/websocket-mock.d.ts

@@ -20,4 +20,3 @@ export declare class MockWebSocketAdapter implements WebSocketAdapter {
     upgrade(_request: Request, handler: (ws: WebSocketConnection) => Promisable<void>): Promisable<Response | undefined>;
     attach(router: XRPCRouter): SubscriptionMock;
 }
-//# sourceMappingURL=websocket-mock.d.ts.map

package/dist/main/utils/websocket-mock.js

@@ -73,4 +73,3 @@ export class MockWebSocketAdapter {
         };
     }
 }
-//# sourceMappingURL=websocket-mock.js.map

package/dist/main/xrpc-error.d.ts

@@ -1,7 +1,6 @@
 /**
- * a single WWW-Authenticate challenge. exactly one of `params` or `token68` may
- * be provided. a bare scheme (no params, no token) is valid and renders as just
- * the scheme name.
+ * a single WWW-Authenticate challenge. exactly one of `params` or `token68` may be provided. a bare scheme
+ * (no params, no token) is valid and renders as just the scheme name.
  *
  * @see {@link https://datatracker.ietf.org/doc/html/rfc7235#section-4.1 | RFC 7235 §4.1}
  */
@@ -11,26 +10,26 @@ export interface WWWAuthenticateChallenge {
     /** auth-param pairs. entries whose value is `undefined` are omitted. */
     params?: Record<string, string | undefined>;
     /**
-     * token68 value for schemes that carry one instead of auth-params (e.g.
-     * `Basic`). mutually exclusive with `params`.
+     * token68 value for schemes that carry one instead of auth-params (e.g. `Basic`). mutually exclusive with
+     * `params`.
      */
     token68?: string;
 }
 /**
  * formats one or more WWW-Authenticate challenges into a single header value.
  *
- * each challenge is emitted as `<scheme>` followed by its params or token68.
- * multiple challenges are joined with `, `. auth-param values are quoted using
- * `JSON.stringify` (RFC 7230 quoted-string semantics for ASCII content).
+ * each challenge is emitted as `<scheme>` followed by its params or token68. multiple challenges are joined
+ * with `, `. auth-param values are quoted using `JSON.stringify` (RFC 7230 quoted-string semantics for ASCII
+ * content).
+ *
+ * @example
+ * 	```ts
+ * 	formatWWWAuthenticate({ scheme: 'Bearer', params: { error: 'BadJwtSignature' } });
+ * 	// => `Bearer error="BadJwtSignature"`
+ * 	```
  *
  * @param challenges one challenge, or an ordered array of challenges
  * @returns the formatted header value
- *
- * @example
- * ```ts
- * formatWWWAuthenticate({ scheme: 'Bearer', params: { error: 'BadJwtSignature' } })
- * // => `Bearer error="BadJwtSignature"`
- * ```
  */
 export declare const formatWWWAuthenticate: (challenges: WWWAuthenticateChallenge | WWWAuthenticateChallenge[]) => string;
 export interface XRPCErrorOptions {
@@ -54,9 +53,9 @@ export declare class InvalidRequestError extends XRPCError {
 }
 export interface AuthRequiredErrorOptions extends Partial<XRPCErrorOptions> {
     /**
-     * WWW-Authenticate challenge(s) to attach to the response. the formatted
-     * header is set on `headers` automatically, and `access-control-expose-headers`
-     * is appended so browsers can read it from CORS responses.
+     * WWW-Authenticate challenge(s) to attach to the response. the formatted header is set on `headers`
+     * automatically, and `access-control-expose-headers` is appended so browsers can read it from CORS
+     * responses.
      */
     wwwAuthenticate?: WWWAuthenticateChallenge | WWWAuthenticateChallenge[];
 }
@@ -91,4 +90,3 @@ export declare class XRPCSubscriptionError extends Error {
     readonly error: string;
     constructor({ closeCode, error, message }: XRPCSubscriptionErrorOptions);
 }
-//# sourceMappingURL=xrpc-error.d.ts.map