@superblocksteam/sdk-api 0.0.12-body-types → 0.0.13

package/src/integrations/base/request-body.ts

@@ -3,44 +3,38 @@ import { z } from "zod";
 
 import type { Property } from "@superblocksteam/types/dist/src/common/v1/plugin_pb";
 
-import { RestApiValidationError } from "../../errors.js";
+import { findBinaryDataPath, isBinaryData } from "../../errors.js";
+import { describeOptionValue, validationError } from "../utils.js";
 import { REST_API_BODY_TYPES } from "./types.js";
-import type { BinaryBody } from "./types.js";
 
-export const MAX_BINARY_BODY_BYTES = 20 * 1024 * 1024;
-
-const REQUEST_BODY_SIZE_ERROR_MESSAGE =
-  "request bodies must be 20 MiB or smaller because agent requests have a 28 MiB serialized size cap";
+type BinaryBody = ArrayBuffer | ArrayBufferView;
 
 type RequestBodyWireType =
   | "jsonBody"
   | "rawBody"
-  | "formData"
   | "formDataBase64"
   | "binaryBody";
-type InjectedHeader = { readonly key: string; readonly value: string };
 
-export type RequestBodyWirePatch = {
+/**
+ * Fields safe to spread directly onto the proto `RestApiRequest`. Never
+ * carries `contentType`: that is a header directive, not a wire field, and
+ * lives on `EncodedRequestBody` instead so a caller cannot spread it onto
+ * the wire message by mistake.
+ */
+export type RequestBodyWireFields = {
   readonly body?: string;
-  readonly formData?: readonly PartialMessage<Property>[];
+  readonly formData?: PartialMessage<Property>[];
   readonly bodyType?: RequestBodyWireType;
-  readonly injectedHeaders: readonly InjectedHeader[];
 };
 
-type MultipartPart =
-  | {
-      readonly kind: "field";
-      readonly key: string;
-      readonly value: string;
-      readonly byteLength: number;
-    }
-  | {
-      readonly kind: "file";
-      readonly key: string;
-      readonly value: string | BinaryBody;
-      readonly filename: string;
-      readonly byteLength: number;
-    };
+/**
+ * The encoder's full result: wire fields plus an optional Content-Type the
+ * caller must push onto request headers itself.
+ */
+export type EncodedRequestBody = {
+  readonly wire: RequestBodyWireFields;
+  readonly contentType?: string;
+};
 
 const requestBodyTypeSchema = z.enum(REST_API_BODY_TYPES);
 
@@ -48,51 +42,85 @@ export function encodeRequestBody(input: {
   body: unknown;
   bodyType?: unknown;
   headers?: Record<string, string>;
-}): RequestBodyWirePatch {
+}): EncodedRequestBody {
   const bodyTypeResult = requestBodyTypeSchema.safeParse(
-    input.bodyType ?? "json",
+    input.bodyType === undefined ? "json" : input.bodyType,
   );
   if (!bodyTypeResult.success) {
-    throw new RestApiValidationError(
-      `Unsupported bodyType ${JSON.stringify(input.bodyType)} - expected one of: ${REST_API_BODY_TYPES.join(", ")}`,
-      { data: input.bodyType, zodError: bodyTypeResult.error },
+    throw validationError(
+      `Unsupported bodyType ${describeOptionValue(input.bodyType)} - expected one of: ${REST_API_BODY_TYPES.join(", ")}`,
+      ["bodyType"],
     );
   }
 
   const bodyType = bodyTypeResult.data;
   if (input.body === undefined) {
-    if (bodyType === "json") return { injectedHeaders: [] };
-    throw validationError(
-      `bodyType "${bodyType}" requires a request body`,
-      input.body,
-      ["body"],
-    );
+    if (bodyType === "json") return { wire: {} };
+    throw validationError(`bodyType "${bodyType}" requires a request body`, [
+      "body",
+    ]);
   }
 
   switch (bodyType) {
     case "json":
-      return encodeJsonBody(input.body);
+      return { wire: encodeJsonBody(input.body) };
     case "raw":
-      return encodeRawBody(input.body);
+      return { wire: encodeRawBody(input.body) };
     case "formUrlencoded":
       return encodeFormUrlencodedBody(input.body, input.headers);
     case "multipartForm":
-      return encodeMultipartFormBody(input.body, input.headers);
+      return { wire: encodeMultipartFormBody(input.body, input.headers) };
     case "binary":
       return encodeBinaryBody(input.body, input.headers);
-    default: {
-      const _exhaustive: never = bodyType;
-      return _exhaustive;
-    }
   }
 }
 
-function encodeJsonBody(body: unknown): RequestBodyWirePatch {
-  if (isBinaryBody(body)) {
+// JSON.stringify's own error text is unbounded: a circular-structure message
+// embeds the caller's full property path and constructor names, and a
+// throwing toJSON()/getter contributes an arbitrary caller-authored string.
+// Every other message in this module goes through describeOptionValue's
+// bounded conventions; classify the failure instead of echoing its text.
+function describeJsonSerializationFailure(error: unknown): string {
+  if (
+    error instanceof TypeError &&
+    /circular (structure|reference)/i.test(error.message)
+  ) {
+    return "the body contains a circular reference";
+  }
+  if (error instanceof TypeError && /BigInt/i.test(error.message)) {
+    return "the body contains a BigInt value";
+  }
+  return "a nested value's toJSON, toString, or getter threw while serializing the body";
+}
+
+function encodeJsonBody(body: unknown): RequestBodyWireFields {
+  if (isBinaryData(body)) {
+    throw validationError('Binary request bodies require bodyType: "binary"', [
+      "body",
+    ]);
+  }
+  // The walk itself only ever throws MAX_BINARY_SCAN_DEPTH's RangeError
+  // (see errors.ts); anything else (a throwing getter, an unusual toJSON)
+  // is left for JSON.stringify to judge below, which reports the same
+  // failure as a serialization error. A depth-capped walk fails closed
+  // instead: treat the body as containing binary at an unknown location
+  // rather than assume none, because JSON.stringify does not throw on a
+  // Uint8Array/Buffer/typed array -- the exact shape this check exists to
+  // catch -- it silently serializes them into digit-keyed garbage.
+  let binaryPath: (string | number)[] | undefined;
+  try {
+    binaryPath = findBinaryDataPath(body, isBinaryData);
+  } catch (error) {
+    binaryPath = error instanceof RangeError ? [] : undefined;
+  }
+  if (binaryPath !== undefined) {
+    const location =
+      binaryPath.length > 0
+        ? ` at ${describeOptionValue(binaryPath.join("."))}`
+        : "";
     throw validationError(
-      'Binary request bodies require bodyType: "binary"',
-      body,
-      ["body"],
+      `bodyType "json" request body contains binary data${location}; send file parts with bodyType: "multipartForm" as { value, filename }, or send bytes alone with bodyType: "binary"`,
+      ["body", ...binaryPath],
     );
   }
   let serialized: string | undefined;
@@ -100,87 +128,99 @@ function encodeJsonBody(body: unknown): RequestBodyWirePatch {
     serialized = JSON.stringify(body);
   } catch (error) {
     throw validationError(
-      `JSON request body could not be serialized: ${errorMessage(error)}`,
-      body,
+      `bodyType "json" request body is not JSON-serializable: ${describeJsonSerializationFailure(error)}`,
       ["body"],
     );
   }
   if (serialized === undefined) {
     throw validationError(
-      "JSON request body must serialize to a JSON value",
-      body,
+      `bodyType "json" cannot serialize a ${typeof body} request body`,
       ["body"],
     );
   }
-  validateRequestByteLength(utf8ByteLength(serialized), ["body"]);
-  return { body: serialized, bodyType: "jsonBody", injectedHeaders: [] };
+  return { body: serialized, bodyType: "jsonBody" };
 }
 
-function encodeRawBody(body: unknown): RequestBodyWirePatch {
+function encodeRawBody(body: unknown): RequestBodyWireFields {
   if (typeof body !== "string" || body.length === 0) {
     throw validationError(
       'bodyType "raw" requires a non-empty string request body',
-      body,
       ["body"],
     );
   }
-  validateRequestByteLength(utf8ByteLength(body), ["body"]);
-  return { body, bodyType: "rawBody", injectedHeaders: [] };
+  return { body, bodyType: "rawBody" };
+}
+
+// A field's value may be a scalar or an array; either way, undefined items
+// (an explicitly-undefined optional field, or an undefined array element)
+// are omitted rather than encoded, matching JSON.stringify's default-body
+// semantics. Shared by encodeFormUrlencodedBody and encodeMultipartFormBody.
+function definedArrayValues(value: unknown): unknown[] {
+  return (Array.isArray(value) ? value : [value]).filter(
+    (item) => item !== undefined,
+  );
 }
 
 function encodeFormUrlencodedBody(
   body: unknown,
   headers: Record<string, string> | undefined,
-): RequestBodyWirePatch {
+): EncodedRequestBody {
   if (!isPlainRecord(body)) {
     throw validationError(
       'bodyType "formUrlencoded" requires a plain object request body',
-      body,
       ["body"],
     );
   }
-  const params = new URLSearchParams();
+  const pairs: string[] = [];
   for (const [key, value] of Object.entries(body)) {
     if (value === undefined) continue;
     if (key.length === 0) {
       throw validationError(
         "formUrlencoded body keys must be non-empty strings",
-        body,
         ["body", key],
       );
     }
-    appendFormUrlencodedValue(params, key, value);
+    const encodedKey = formUrlencode(key, key);
+    for (const item of definedArrayValues(value)) {
+      pairs.push(
+        `${encodedKey}=${formUrlencode(formUrlencodedPrimitiveToString(key, item), key)}`,
+      );
+    }
   }
-  const encodedBody = params.toString();
-  if (encodedBody.length === 0) {
+  if (pairs.length === 0) {
     throw validationError(
       "formUrlencoded body must encode at least one field",
-      body,
       ["body"],
     );
   }
-  validateRequestByteLength(utf8ByteLength(encodedBody), ["body"]);
   return {
-    body: encodedBody,
-    bodyType: "rawBody",
-    injectedHeaders: contentTypeHeaderIfMissing(
+    wire: { body: pairs.join("&"), bodyType: "rawBody" },
+    contentType: contentTypeIfMissing(
       headers,
       "application/x-www-form-urlencoded",
     ),
   };
 }
 
-function appendFormUrlencodedValue(
-  params: URLSearchParams,
-  key: string,
-  value: unknown,
-): void {
-  if (Array.isArray(value)) {
-    for (const item of value)
-      params.append(key, formUrlencodedPrimitiveToString(key, item));
-    return;
+// The WASM sdk-api sandbox has no URLSearchParams global, so encode by hand.
+// encodeURIComponent's unreserved set leaves `! ' ( ) ~` unescaped, but the
+// WHATWG application/x-www-form-urlencoded safe set (what URLSearchParams
+// produces) escapes those five; only alphanumerics, `* - . _`, and space
+// (as `+`) stay literal.
+function formUrlencode(value: string, key: string): string {
+  try {
+    return encodeURIComponent(value)
+      .replace(/%20/g, "+")
+      .replace(
+        /[!'()~]/g,
+        (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`,
+      );
+  } catch {
+    throw validationError(
+      `formUrlencoded field ${describeOptionValue(key)} contains a lone surrogate and cannot be percent-encoded`,
+      ["body", key],
+    );
   }
-  params.append(key, formUrlencodedPrimitiveToString(key, value));
 }
 
 function formUrlencodedPrimitiveToString(key: string, value: unknown): string {
@@ -189,14 +229,12 @@ function formUrlencodedPrimitiveToString(key: string, value: unknown): string {
   if (typeof value === "number" && Number.isFinite(value)) return String(value);
   if (typeof value === "object" && value !== null) {
     throw validationError(
-      `formUrlencoded field "${key}" is nested; flatten it using bracket notation such as "metadata[order_id]"`,
-      value,
+      `formUrlencoded field ${describeOptionValue(key)} is nested; flatten it using bracket notation such as "metadata[order_id]"`,
       ["body", key],
     );
   }
   throw validationError(
-    `formUrlencoded field "${key}" must be a string, finite number, boolean, or array of those values`,
-    value,
+    `formUrlencoded field ${describeOptionValue(key)} must be a string, finite number, boolean, or array of those values`,
     ["body", key],
   );
 }
@@ -204,96 +242,74 @@ function formUrlencodedPrimitiveToString(key: string, value: unknown): string {
 function encodeBinaryBody(
   body: unknown,
   headers: Record<string, string> | undefined,
-): RequestBodyWirePatch {
-  if (!isBinaryBody(body)) {
+): EncodedRequestBody {
+  if (!isBinaryData(body)) {
     throw validationError(
       'bodyType "binary" requires an ArrayBuffer or ArrayBufferView request body',
-      body,
       ["body"],
     );
   }
-  const bytes = binaryBodyToBytes(body);
-  validateBinaryBodyByteLength(bytes.byteLength, body, ["body"]);
+  if (body.byteLength === 0) {
+    throw validationError("binary request bodies must be non-empty", ["body"]);
+  }
   return {
-    body: base64Encode(bytes),
-    bodyType: "binaryBody",
-    injectedHeaders: contentTypeHeaderIfMissing(
-      headers,
-      "application/octet-stream",
-    ),
+    wire: { body: toBuffer(body).toString("base64"), bodyType: "binaryBody" },
+    contentType: contentTypeIfMissing(headers, "application/octet-stream"),
   };
 }
 
 function encodeMultipartFormBody(
   body: unknown,
   headers: Record<string, string> | undefined,
-): RequestBodyWirePatch {
+): RequestBodyWireFields {
   if (hasHeader(headers, "content-type")) {
     throw validationError(
       "multipartForm bodies cannot provide Content-Type because the multipart boundary is generated at execution time",
-      body,
       ["headers", "Content-Type"],
     );
   }
-  if (!isPlainRecord(body) || Object.keys(body).length === 0) {
-    throw validationError(
-      'bodyType "multipartForm" requires a plain non-empty object request body',
-      body,
-      ["body"],
-    );
-  }
-  const parts = Object.entries(body)
-    .filter(([_key, value]) => value !== undefined)
-    .map(([key, value]) => parseMultipartPart(key, value));
-  if (parts.length === 0) {
+  if (!isPlainRecord(body)) {
     throw validationError(
-      "multipartForm body must encode at least one field",
-      body,
+      'bodyType "multipartForm" requires a plain object request body',
       ["body"],
     );
   }
-  validateRequestByteLength(totalMultipartPartBytes(parts), ["body"]);
-  const hasBinaryFile = parts.some(
-    (part) => part.kind === "file" && isBinaryBody(part.value),
+  const formData = Object.entries(body).flatMap(([key, value]) =>
+    definedArrayValues(value).map((item) => parseMultipartPart(key, item)),
   );
-  return {
-    bodyType: hasBinaryFile ? "formDataBase64" : "formData",
-    formData: parts.map((part) => multipartPartToWire(part, hasBinaryFile)),
-    injectedHeaders: [],
-  };
+  if (formData.length === 0) {
+    throw validationError("multipartForm body must encode at least one field", [
+      "body",
+    ]);
+  }
+  return { bodyType: "formDataBase64", formData };
 }
 
-function parseMultipartPart(key: string, value: unknown): MultipartPart {
+function parseMultipartPart(
+  key: string,
+  value: unknown,
+): PartialMessage<Property> {
   if (key.length === 0)
-    throw validationError(
-      "multipartForm body keys must be non-empty strings",
-      value,
-      ["body", key],
-    );
+    throw validationError("multipartForm body keys must be non-empty strings", [
+      "body",
+      key,
+    ]);
   if (
     typeof value === "string" ||
-    typeof value === "number" ||
-    typeof value === "boolean"
+    typeof value === "boolean" ||
+    (typeof value === "number" && Number.isFinite(value))
   ) {
-    const stringValue = String(value);
-    return {
-      kind: "field",
-      key,
-      value: stringValue,
-      byteLength: utf8ByteLength(stringValue),
-    };
+    return { key, value: String(value) };
   }
-  if (isBinaryBody(value)) {
+  if (isBinaryData(value)) {
     throw validationError(
-      `multipartForm binary field "${key}" must be wrapped as { value, filename }`,
-      value,
+      `multipartForm binary field ${describeOptionValue(key)} must be wrapped as { value, filename }`,
       ["body", key],
     );
   }
   if (!isPlainRecord(value)) {
     throw validationError(
-      `multipartForm field "${key}" must be a primitive value or { value, filename } file part`,
-      value,
+      `multipartForm field ${describeOptionValue(key)} must be a primitive value or { value, filename } file part`,
       ["body", key],
     );
   }
@@ -305,8 +321,7 @@ function parseMultipartPart(key: string, value: unknown): MultipartPart {
   );
   if (missingKeys.length > 0) {
     throw validationError(
-      `multipartForm file part "${key}" is missing required ${pluralize("key", missingKeys)}: ${missingKeys.join(", ")}`,
-      value,
+      `multipartForm file part ${describeOptionValue(key)} is missing required ${pluralize("key", missingKeys)}: ${missingKeys.join(", ")}`,
       ["body", key],
     );
   }
@@ -314,73 +329,29 @@ function parseMultipartPart(key: string, value: unknown): MultipartPart {
     (partKey) => partKey !== "value" && partKey !== "filename",
   );
   if (unexpectedKeys.length > 0) {
+    const shown = unexpectedKeys.slice(0, 5).map(describeOptionValue);
+    const suffix = unexpectedKeys.length > 5 ? ", ..." : "";
     throw validationError(
-      `multipartForm file part "${key}" has unexpected ${pluralize("key", unexpectedKeys)}: ${unexpectedKeys.join(", ")}`,
-      value,
+      `multipartForm file part ${describeOptionValue(key)} has unexpected ${pluralize("key", unexpectedKeys)}: ${shown.join(", ")}${suffix}`,
       ["body", key],
     );
   }
   if (typeof value.filename !== "string" || value.filename.length === 0) {
     throw validationError(
-      `multipartForm file part "${key}" requires a non-empty filename`,
-      value,
+      `multipartForm file part ${describeOptionValue(key)} requires a non-empty filename`,
       ["body", key, "filename"],
     );
   }
-  if (typeof value.value !== "string" && !isBinaryBody(value.value)) {
+  if (typeof value.value !== "string" && !isBinaryData(value.value)) {
     throw validationError(
-      `multipartForm file part "${key}" value must be a string or binary body`,
-      value,
+      `multipartForm file part ${describeOptionValue(key)} value must be a string or binary body`,
       ["body", key, "value"],
     );
   }
-  const byteLength = isBinaryBody(value.value)
-    ? binaryBodyToBytes(value.value).byteLength
-    : utf8ByteLength(value.value);
-  validateMultipartFilePartByteLength(byteLength, value.value, [
-    "body",
-    key,
-    "value",
-  ]);
   return {
-    kind: "file",
     key,
-    value: value.value,
-    filename: value.filename,
-    byteLength,
-  };
-}
-
-function totalMultipartPartBytes(parts: MultipartPart[]): number {
-  return parts.reduce((total, part) => total + part.byteLength, 0);
-}
-
-function multipartPartToWire(
-  part: MultipartPart,
-  encodeFilePartsAsBase64: boolean,
-): PartialMessage<Property> {
-  if (part.kind === "field") return { key: part.key, value: part.value };
-  if (!encodeFilePartsAsBase64) {
-    if (typeof part.value !== "string") {
-      throw validationError(
-        "multipartForm binary file parts require formDataBase64 encoding",
-        part.value,
-        ["body", part.key, "value"],
-      );
-    }
-    return {
-      key: part.key,
-      value: part.value,
-      file: { filename: part.filename },
-    };
-  }
-  const bytes = isBinaryBody(part.value)
-    ? binaryBodyToBytes(part.value)
-    : textToUtf8Bytes(part.value);
-  return {
-    key: part.key,
-    value: base64Encode(bytes),
-    file: { filename: part.filename },
+    value: toBuffer(value.value).toString("base64"),
+    file: { filename: value.filename },
   };
 }
 
@@ -391,58 +362,17 @@ function isPlainRecord(value: unknown): value is Record<string, unknown> {
   return prototype === Object.prototype || prototype === null;
 }
 
-function isBinaryBody(value: unknown): value is BinaryBody {
-  return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
-}
-
-function binaryBodyToBytes(value: BinaryBody): Uint8Array {
-  if (value instanceof ArrayBuffer) return new Uint8Array(value);
-  return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+function toBuffer(value: string | BinaryBody): Buffer {
+  if (typeof value === "string") return Buffer.from(value, "utf8");
+  if (value instanceof ArrayBuffer) return Buffer.from(value);
+  return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
 }
 
-function validateBinaryBodyByteLength(
-  byteLength: number,
-  data: unknown,
-  path: (string | number)[],
-): void {
-  if (byteLength === 0)
-    throw validationError(
-      "binary request bodies must be non-empty",
-      data,
-      path,
-    );
-  validateRequestByteLength(byteLength, path, data);
-}
-
-function validateMultipartFilePartByteLength(
-  byteLength: number,
-  data: string | BinaryBody,
-  path: (string | number)[],
-): void {
-  if (byteLength <= MAX_BINARY_BODY_BYTES) return;
-  throw validationError(
-    REQUEST_BODY_SIZE_ERROR_MESSAGE,
-    isBinaryBody(data) ? data : { byteLength },
-    path,
-  );
-}
-
-function validateRequestByteLength(
-  byteLength: number,
-  path: (string | number)[],
-  data: unknown = { byteLength },
-): void {
-  if (byteLength <= MAX_BINARY_BODY_BYTES) return;
-  throw validationError(REQUEST_BODY_SIZE_ERROR_MESSAGE, data, path);
-}
-
-function contentTypeHeaderIfMissing(
+function contentTypeIfMissing(
   headers: Record<string, string> | undefined,
   value: string,
-): readonly InjectedHeader[] {
-  return hasHeader(headers, "content-type")
-    ? []
-    : [{ key: "Content-Type", value }];
+): string | undefined {
+  return hasHeader(headers, "content-type") ? undefined : value;
 }
 
 function hasHeader(
@@ -457,92 +387,6 @@ function hasHeader(
   );
 }
 
-function base64Encode(bytes: Uint8Array): string {
-  if (typeof Buffer !== "undefined")
-    return Buffer.from(
-      bytes.buffer,
-      bytes.byteOffset,
-      bytes.byteLength,
-    ).toString("base64");
-  const alphabet =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  let output = "";
-  for (let index = 0; index < bytes.length; index += 3) {
-    const first = bytes[index];
-    const second = bytes[index + 1];
-    const third = bytes[index + 2];
-    output += alphabet[first >> 2];
-    output += alphabet[((first & 0x03) << 4) | ((second ?? 0) >> 4)];
-    output +=
-      second === undefined
-        ? "="
-        : alphabet[((second & 0x0f) << 2) | ((third ?? 0) >> 6)];
-    output += third === undefined ? "=" : alphabet[third & 0x3f];
-  }
-  return output;
-}
-
-function textToUtf8Bytes(value: string): Uint8Array {
-  if (typeof TextEncoder !== "undefined")
-    return new TextEncoder().encode(value);
-  const bytes: number[] = [];
-  for (let index = 0; index < value.length; index += 1) {
-    const codePoint = value.codePointAt(index);
-    if (codePoint === undefined) continue;
-    if (codePoint > 0xffff) index += 1;
-    appendCodePointAsUtf8(bytes, codePoint);
-  }
-  return Uint8Array.from(bytes);
-}
-
-function utf8ByteLength(value: string): number {
-  let byteLength = 0;
-  for (let index = 0; index < value.length; index += 1) {
-    const codePoint = value.codePointAt(index);
-    if (codePoint === undefined) continue;
-    if (codePoint > 0xffff) index += 1;
-    if (codePoint <= 0x7f) byteLength += 1;
-    else if (codePoint <= 0x7ff) byteLength += 2;
-    else if (codePoint <= 0xffff) byteLength += 3;
-    else byteLength += 4;
-  }
-  return byteLength;
-}
-
 function pluralize(word: string, values: readonly unknown[]): string {
   return values.length === 1 ? word : `${word}s`;
 }
-
-function appendCodePointAsUtf8(bytes: number[], codePoint: number): void {
-  if (codePoint <= 0x7f) bytes.push(codePoint);
-  else if (codePoint <= 0x7ff)
-    bytes.push(0xc0 | (codePoint >> 6), 0x80 | (codePoint & 0x3f));
-  else if (codePoint <= 0xffff)
-    bytes.push(
-      0xe0 | (codePoint >> 12),
-      0x80 | ((codePoint >> 6) & 0x3f),
-      0x80 | (codePoint & 0x3f),
-    );
-  else
-    bytes.push(
-      0xf0 | (codePoint >> 18),
-      0x80 | ((codePoint >> 12) & 0x3f),
-      0x80 | ((codePoint >> 6) & 0x3f),
-      0x80 | (codePoint & 0x3f),
-    );
-}
-
-function validationError(
-  message: string,
-  data: unknown,
-  path: (string | number)[],
-): RestApiValidationError {
-  return new RestApiValidationError(message, {
-    data,
-    zodError: new z.ZodError([{ code: z.ZodIssueCode.custom, message, path }]),
-  });
-}
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}