@beignet/core 0.0.34 → 0.0.36

package/src/server/use-case-route.ts

@@ -258,7 +258,7 @@ type HooksOf<E> = E extends { hooks: infer H extends readonly unknown[] }
 
 /**
  * Per-element binder validation applied where route tuples are inferred, such
- * as `defineRouteGroup<Ctx>()({ ... })`, so contract/use-case mismatches are
+ * as an app-bound `defineRouteGroup({ ... })`, so contract/use-case mismatches are
  * reported on the individual route literal.
  */
 export type ValidatedRouteInput<Ctx, E> = E extends {

package/src/tracing/index.ts

@@ -93,6 +93,7 @@ export type TraceSpanKind =
 export type TraceOperationType =
   | "request"
   | "useCase"
+  | "agentCapability"
   | "listener"
   | "job"
   | "schedule"

package/src/uploads/client.ts

@@ -688,7 +688,7 @@ async function requestJson<Result>(args: {
 
   const body = await parseJsonBody(response, args);
   if (!response.ok) {
-    const envelope = uploadErrorEnvelope(body);
+    const envelope = uploadErrorBody(body);
     throw new UploadClientError({
       operation: args.operation,
       uploadName: args.uploadName,
@@ -725,17 +725,14 @@ async function parseJsonBody(
   }
 }
 
-function uploadErrorEnvelope(
+function uploadErrorBody(
   body: unknown,
 ): { code?: string; message?: string; details?: unknown } | undefined {
-  if (typeof body !== "object" || body === null || !("error" in body)) {
+  if (typeof body !== "object" || body === null) {
     return undefined;
   }
 
-  const error = body.error;
-  if (typeof error !== "object" || error === null) return undefined;
-
-  const errorRecord = error as Record<string, unknown>;
+  const errorRecord = body as Record<string, unknown>;
 
   return {
     code: typeof errorRecord.code === "string" ? errorRecord.code : undefined,

package/src/uploads/index.ts

@@ -1166,12 +1166,23 @@ export function createUploadRouter<Ctx>(
           );
         }
 
-        assertUploadContentLengthWithinLimit(request.headers, {
+        const multipartContext = {
           uploadName: requestOptions.uploadName,
           action: "upload",
           maxBytes: requestLimits.multipartMaxBytes,
-        });
-        const formData = await request.formData();
+        } as const;
+        const multipartBody = await readLimitedRequestBytes(
+          request,
+          multipartContext,
+        );
+        const multipartHeaders = new Headers(request.headers);
+        multipartHeaders.delete("content-length");
+        const formData = await new Request(request.url, {
+          method: request.method,
+          headers: multipartHeaders,
+          body: multipartBody,
+          signal: request.signal,
+        }).formData();
         return jsonResponse(
           await upload(requestOptions.uploadName, {
             formData,
@@ -1240,6 +1251,57 @@ function assertUploadContentLengthWithinLimit(
   }
 }
 
+async function readLimitedRequestBytes(
+  request: Request,
+  context: {
+    uploadName: string;
+    action: "upload";
+    maxBytes: number;
+  },
+): Promise<ArrayBuffer> {
+  assertUploadContentLengthWithinLimit(request.headers, context);
+
+  if (!request.body) return new ArrayBuffer(0);
+
+  const reader = request.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let actualBytes = 0;
+
+  try {
+    while (true) {
+      const result = await reader.read();
+      if (result.done) break;
+      actualBytes += result.value.byteLength;
+      if (actualBytes > context.maxBytes) {
+        try {
+          await reader.cancel();
+        } catch {
+          // Preserve the size-limit error when the request source rejects cancellation.
+        }
+        throw new UploadBodyTooLargeError({
+          message: `Upload "${context.uploadName}" ${context.action} body is too large.`,
+          details: {
+            maxBytes: context.maxBytes,
+            actualBytes,
+          },
+        });
+      }
+      chunks.push(result.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const body = new ArrayBuffer(actualBytes);
+  const bytes = new Uint8Array(body);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+
 async function readLimitedRequestText(
   request: Request,
   context: {
@@ -2000,11 +2062,9 @@ function uploadErrorResponse(error: unknown): Response {
   if (error instanceof UploadError) {
     return jsonResponse(
       {
-        error: {
-          code: error.code,
-          message: error.message,
-          ...(error.details !== undefined ? { details: error.details } : {}),
-        },
+        code: error.code,
+        message: error.message,
+        ...(error.details !== undefined ? { details: error.details } : {}),
       },
       { status: error.status },
     );
@@ -2012,10 +2072,8 @@ function uploadErrorResponse(error: unknown): Response {
 
   return jsonResponse(
     {
-      error: {
-        code: "INTERNAL_SERVER_ERROR",
-        message: "Internal server error",
-      },
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Internal server error",
     },
     { status: 500 },
   );