The best way to control Claude Code, Codex and more from any computer or phone
| 1 | // Alchemy modifications are licensed under Apache-2.0. |
| 2 | // This file includes third-party code; see /THIRD_PARTY_LICENSES.md. |
| 3 | // Vendored from `@astrojs/cloudflare` v14.4.2 (`src/utils/prerender-response.ts`). |
| 4 | /** |
| 5 | * Node-side reader for the framed prerender responses the prerender worker |
| 6 | * writes with `createFramedPrerenderResponse`. Kept out of the worker runtime |
| 7 | * so the metadata Schema never ships in the worker bundle. |
| 8 | */ |
| 9 | import type { PrerenderRenderMetadata } from "astro"; |
| 10 | import * as Schema from "effect/Schema"; |
| 11 | import { |
| 12 | MAX_METADATA_LENGTH, |
| 13 | METADATA_LENGTH_BYTES, |
| 14 | PRERENDER_RESPONSE_CONTENT_TYPE, |
| 15 | } from "./runtime/utils/prerender-response.ts"; |
| 16 | |
| 17 | const NULL_BODY_STATUSES = new Set([204, 205, 304]); |
| 18 | |
| 19 | const ResponseMetadata = Schema.Struct({ |
| 20 | status: Schema.Int.check(Schema.isBetween({ minimum: 200, maximum: 599 })), |
| 21 | statusText: Schema.String, |
| 22 | headers: Schema.Array(Schema.Tuple([Schema.String, Schema.String])), |
| 23 | hasBody: Schema.Boolean, |
| 24 | metadata: Schema.optional( |
| 25 | Schema.Struct({ |
| 26 | contentEntryKeys: Schema.Array(Schema.String), |
| 27 | staticImages: Schema.Array(Schema.Unknown), |
| 28 | referencedImages: Schema.String.pipe(Schema.Array, Schema.optional), |
| 29 | }), |
| 30 | ), |
| 31 | }).check( |
| 32 | Schema.makeFilter(({ status, hasBody }) => !(hasBody && NULL_BODY_STATUSES.has(status)), { |
| 33 | message: "a null-body status cannot carry a body", |
| 34 | }), |
| 35 | ); |
| 36 | |
| 37 | // oxlint-disable-next-line effecttsgo/schema-sync -- decoded inside an async, non-Effect reader |
| 38 | const decodeResponseMetadata = Schema.decodeUnknownSync(Schema.fromJsonString(ResponseMetadata)); |
| 39 | |
| 40 | export async function readFramedPrerenderResponse( |
| 41 | transportResponse: Response, |
| 42 | ): Promise<{ response: Response; metadata: PrerenderRenderMetadata | undefined }> { |
| 43 | if (!transportResponse.ok) { |
| 44 | throw new Error( |
| 45 | `The framed prerender request failed (${transportResponse.status}: ${transportResponse.statusText}).`, |
| 46 | ); |
| 47 | } |
| 48 | if (transportResponse.headers.get("Content-Type") !== PRERENDER_RESPONSE_CONTENT_TYPE) { |
| 49 | throw new Error("The prerender response is not framed."); |
| 50 | } |
| 51 | if (!transportResponse.body) { |
| 52 | throw new Error("The framed prerender response has no body."); |
| 53 | } |
| 54 | |
| 55 | const reader = transportResponse.body.getReader(); |
| 56 | let chunk: Uint8Array | undefined; |
| 57 | let chunkOffset = 0; |
| 58 | const nextChunk = async (): Promise<Uint8Array> => { |
| 59 | const next = await reader.read(); |
| 60 | if (next.done) throw new Error("The framed prerender response ended unexpectedly."); |
| 61 | chunk = next.value; |
| 62 | chunkOffset = 0; |
| 63 | return next.value; |
| 64 | }; |
| 65 | const readExactly = async (length: number): Promise<Uint8Array> => { |
| 66 | const bytes = new Uint8Array(length); |
| 67 | let bytesRead = 0; |
| 68 | while (bytesRead < length) { |
| 69 | const current = chunk && chunkOffset < chunk.byteLength ? chunk : await nextChunk(); |
| 70 | const available = current.byteLength - chunkOffset; |
| 71 | const count = Math.min(length - bytesRead, available); |
| 72 | bytes.set(current.subarray(chunkOffset, chunkOffset + count), bytesRead); |
| 73 | chunkOffset += count; |
| 74 | bytesRead += count; |
| 75 | } |
| 76 | return bytes; |
| 77 | }; |
| 78 | |
| 79 | try { |
| 80 | const lengthBytes = await readExactly(METADATA_LENGTH_BYTES); |
| 81 | const metadataLength = new DataView( |
| 82 | lengthBytes.buffer, |
| 83 | lengthBytes.byteOffset, |
| 84 | lengthBytes.byteLength, |
| 85 | ).getUint32(0); |
| 86 | if (metadataLength === 0 || metadataLength > MAX_METADATA_LENGTH) { |
| 87 | throw new Error("The framed prerender response metadata length is invalid."); |
| 88 | } |
| 89 | const metadataBytes = await readExactly(metadataLength); |
| 90 | const responseMetadata = decodeResponseMetadata(new TextDecoder().decode(metadataBytes)); |
| 91 | |
| 92 | let remainder = |
| 93 | chunk && chunkOffset < chunk.byteLength ? chunk.subarray(chunkOffset) : undefined; |
| 94 | let body: ReadableStream<Uint8Array> | null = null; |
| 95 | if (responseMetadata.hasBody) { |
| 96 | body = new ReadableStream<Uint8Array>({ |
| 97 | async pull(controller) { |
| 98 | if (remainder) { |
| 99 | controller.enqueue(remainder); |
| 100 | remainder = undefined; |
| 101 | return; |
| 102 | } |
| 103 | const { done, value } = await reader.read(); |
| 104 | if (done) { |
| 105 | controller.close(); |
| 106 | } else { |
| 107 | controller.enqueue(value); |
| 108 | } |
| 109 | }, |
| 110 | cancel(reason) { |
| 111 | return reader.cancel(reason); |
| 112 | }, |
| 113 | }); |
| 114 | } else { |
| 115 | await reader.cancel(); |
| 116 | } |
| 117 | |
| 118 | return { |
| 119 | response: new Response(body, { |
| 120 | status: responseMetadata.status, |
| 121 | statusText: responseMetadata.statusText, |
| 122 | headers: responseMetadata.headers.map(([name, value]): [string, string] => [name, value]), |
| 123 | }), |
| 124 | metadata: responseMetadata.metadata as PrerenderRenderMetadata | undefined, |
| 125 | }; |
| 126 | } catch (error) { |
| 127 | try { |
| 128 | await reader.cancel(error); |
| 129 | } catch { |
| 130 | // Preserve the framing error when cancellation also fails. |
| 131 | } |
| 132 | throw error; |
| 133 | } |
| 134 | } |