diff --git a/apps/server/src/http.test.ts b/apps/server/src/http.test.ts
index 7b747647984d4..da6f78b641bf4 100644
--- a/apps/server/src/http.test.ts
+++ b/apps/server/src/http.test.ts
@@ -170,6 +170,14 @@ describe("browser API CORS", () => {
expect(allowedHeaders.has(ORCHESTRATION_PROTOCOL_HEADER)).toBe(true);
expect(allowedHeaders.has("authorization")).toBe(true);
expect(allowedHeaders.has("dpop")).toBe(true);
+
+ // Range readers validate offsets and revision from these response headers.
+ const asset = await handler(
+ new Request("https://backend.example/api/environment", {
+ headers: { origin: "https://app.t3.codes" },
+ }),
+ );
+ expect(asset.headers.get("access-control-expose-headers")).toBe("content-range,etag");
} finally {
await dispose();
}
diff --git a/apps/server/src/http.ts b/apps/server/src/http.ts
index fcd7b3c361ee8..2e109e9fd45dc 100644
--- a/apps/server/src/http.ts
+++ b/apps/server/src/http.ts
@@ -289,6 +289,8 @@ export const layerBrowserApiCors = Layer.unwrap(
: {}),
allowedMethods: browserApiCorsAllowedMethods,
allowedHeaders: browserApiCorsAllowedHeaders,
+ // Cross-origin previews validate byte ranges against the size and revision.
+ exposedHeaders: ["content-range", "etag"],
maxAge: 600,
});
return HttpRouter.middleware(
diff --git a/apps/web/src/components/files/BrowserDocumentFrame.tsx b/apps/web/src/components/files/BrowserDocumentFrame.tsx
index bfa699cf252b4..9c70302fe8ff7 100644
--- a/apps/web/src/components/files/BrowserDocumentFrame.tsx
+++ b/apps/web/src/components/files/BrowserDocumentFrame.tsx
@@ -120,6 +120,7 @@ function PdfDocumentRevision(props: {
}>
>\nstream\n${"x".repeat(padding)}\nendstream`;
const objects = [
"<< /Type /Catalog /Pages 2 0 R >>",
`<< /Type /Pages /Count ${pages.length} /Kids [${pages.map((_, index) => `${3 + index * 2} 0 R`).join(" ")}] >>`,
@@ -66,12 +68,19 @@ function testPdf(
]),
"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold >>",
+ ...(padding ? [filler, filler] : []),
];
+ // Unreferenced filler keeps the last page's content out of the first range and the cross-reference table's.
+ const order = objects.map((_, index) => index);
+ if (padding) {
+ const [lastContent] = order.splice(pages.length * 2 + 1, 1);
+ order.splice(-1, 0, lastContent!);
+ }
let source = "%PDF-1.4\n";
const offsets: number[] = [];
- for (const [index, object] of objects.entries()) {
- offsets.push(source.length);
- source += `${index + 1} 0 obj\n${object}\nendobj\n`;
+ for (const index of order) {
+ offsets[index] = source.length;
+ source += `${index + 1} 0 obj\n${objects[index]}\nendobj\n`;
}
const xref = source.length;
source += `xref\n0 ${objects.length + 1}\n0000000000 65535 f \n${offsets
@@ -142,6 +151,109 @@ it("fits the width, then finds split and rotated text and jumps to its page", as
}
});
+it.each([
+ { server: "valid", full: false },
+ { server: "ignored", full: true },
+ { server: "malformed", full: true },
+ { server: "revised", full: true },
+ { server: "renewed", full: false },
+])("opens a PDF from a server with $server ranges", async ({ server, full }) => {
+ const bytes = new Uint8Array(await testPdf(undefined, 200_000).arrayBuffer());
+ const url = "https://assets.example/report.pdf";
+ // The pinned grant has expired; reads must use the renewed one.
+ const expired = `${url}?grant=expired`;
+ const requests: (string | null)[] = [];
+ const realFetch = globalThis.fetch;
+ using _fetch = vi.spyOn(globalThis, "fetch").mockImplementation((input, init) => {
+ if (String(input) === expired) return Promise.resolve(new Response(null, { status: 404 }));
+ if (String(input) !== url) return realFetch(input, init);
+ const range = new Headers(init?.headers).get("range");
+ requests.push(range);
+ const match = /^bytes=(\d+)-(\d+)$/.exec(range ?? "");
+ if (!match || server === "ignored") return Promise.resolve(new Response(bytes));
+ const start = Number(match[1]);
+ const end = Math.min(Number(match[2]), bytes.length - 1);
+ const reported = server === "malformed" ? start + 1 : start;
+ return Promise.resolve(
+ new Response(bytes.slice(start, end + 1), {
+ status: 206,
+ headers: {
+ "content-range": `bytes ${reported}-${end}/${bytes.length}`,
+ etag: server === "revised" && requests.length > 1 ? '"b"' : '"a"',
+ },
+ }),
+ );
+ });
+ await using screen = await render(
+ server === "renewed" ? (
+
+ ) : (
+
+ ),
+ );
+ await expect.element(screen.getByText("1 / 2 pages"), { timeout: 10_000 }).toBeVisible();
+ expect(requests[0]).toBe("bytes=0-65535");
+ expect(requests.includes(null)).toBe(full);
+ if (!full) expect(requests.length).toBeGreaterThan(1);
+});
+
+it("keeps the reading position when a later range forces a full read", async () => {
+ const bytes = new Uint8Array(await testPdf(undefined, 200_000).arrayBuffer());
+ const pageTwo = new TextDecoder().decode(bytes).indexOf("\n6 0 obj");
+ const url = "https://assets.example/report.pdf";
+ const requests: (string | null)[] = [];
+ let fullReadCache: RequestCache | undefined;
+ let revise!: () => void;
+ const revised = new Promise((resolve) => (revise = resolve));
+ const realFetch = globalThis.fetch;
+ using _fetch = vi.spyOn(globalThis, "fetch").mockImplementation(async (input, init) => {
+ if (String(input) !== url) return realFetch(input, init);
+ const range = new Headers(init?.headers).get("range");
+ requests.push(range);
+ const match = /^bytes=(\d+)-(\d+)$/.exec(range ?? "");
+ if (!match) {
+ fullReadCache = init?.cache;
+ return new Response(bytes);
+ }
+ const start = Number(match[1]);
+ const end = Math.min(Number(match[2]), bytes.length - 1);
+ const changed = start <= pageTwo && end > pageTwo;
+ if (changed) await revised;
+ return new Response(bytes.slice(start, end + 1), {
+ status: 206,
+ headers: {
+ "content-range": `bytes ${start}-${end}/${bytes.length}`,
+ etag: changed ? '"b"' : '"a"',
+ },
+ });
+ });
+ await using screen = await render(
+ ,
+ );
+ await expect.element(screen.getByText("1 / 2 pages"), { timeout: 10_000 }).toBeVisible();
+ const region = () => screen.getByRole("region", { name: "Ranged PDF" }).element();
+ const top = 40;
+ const scrolled = new Promise((resolve) =>
+ region().addEventListener("scroll", resolve, { once: true }),
+ );
+ region().scrollTop = top;
+ await scrolled;
+
+ revise();
+ await vi.waitFor(() => {
+ expect(requests).toContain(null);
+ // Page 2 laid out at its own size means the full read replaced the ranged document.
+ const height = (page: number) =>
+ region().querySelector(`canvas[aria-label="Page ${page}"]`)?.getBoundingClientRect().height;
+ expect(height(2)).toBeGreaterThan(height(1)! * 2);
+ });
+ expect(region().scrollTop).toBeCloseTo(top, 0);
+ // The changed file may sit in the HTTP cache from an earlier full read.
+ expect(fullReadCache).toBe("reload");
+});
+
it("jumps to the first hit while still counting and keeps later manual navigation", async () => {
setup(4);
const page = (text: string) => ({
diff --git a/apps/web/src/components/files/PdfViewer.tsx b/apps/web/src/components/files/PdfViewer.tsx
index e5872d123bba3..01d49ad76a982 100644
--- a/apps/web/src/components/files/PdfViewer.tsx
+++ b/apps/web/src/components/files/PdfViewer.tsx
@@ -16,7 +16,7 @@ import { observeResize } from "~/lib/observeResize";
import { FileSurfaceAction, FileSurfaceFailure, FileSurfaceLoading } from "./fileSurfaceChrome";
import { readBoundedDocument } from "./readBoundedDocument";
import { previewErrorText } from "./previewFailureMessages";
-import { openPdf } from "./pdfDocument";
+import { openPdf, openPdfRanges } from "./pdfDocument";
import {
currentPdfPage,
pdfFindIncludes,
@@ -140,6 +140,8 @@ function PdfPage(props: {
export default function PdfViewer(props: {
src: string;
+ /** The renewed grant for `src`; reads use it without reopening the document. */
+ latestSrc?: string;
title: string;
positionKey?: string;
initialView?: PdfViewState;
@@ -149,12 +151,13 @@ export default function PdfViewer(props: {
const [savedPosition] = useState(() =>
props.positionKey === undefined ? undefined : positions.get(props.positionKey),
);
- const [initialView] = useState(
+ const [initialView, setInitialView] = useState(
() => savedPosition ?? props.initialView ?? { page: 0, offset: 0, zoom: null, left: 0 },
);
const [pdf, setPdf] = useState(null);
const [error, setError] = useState(null);
const [revision, setRevision] = useState(0);
+ const [fullRead, setFullRead] = useState(false);
const [ratios, setRatios] = useState([]);
const [zoom, setZoom] = useState(initialView.zoom);
const [pageWidth, setPageWidth] = useState(612);
@@ -168,8 +171,25 @@ export default function PdfViewer(props: {
const scroll = useRef(null);
const find = useRef(null);
const zoomAnchor = useRef<{ page: number; offset: number; width: number } | null>(null);
+ const { scale, width } = pdfPageWidth(viewport.width, pageWidth, zoom);
+ const offsets = pdfPageOffsets(ratios, width);
+ const readView = (node: HTMLDivElement) => {
+ const page = currentPdfPage(offsets, ratios.length, node.scrollTop);
+ return {
+ page,
+ offset: Math.max(0, node.scrollTop - (offsets[page]! - 16)),
+ zoom,
+ left: node.scrollLeft,
+ };
+ };
+ // A range fallback reloads the document; the reader stays where they were.
+ const keepView = useEffectEvent(() => {
+ const node = scroll.current;
+ if (pdf && node) setInitialView({ ...readView(node), width });
+ });
+ const currentSrc = useEffectEvent(() => props.latestSrc ?? props.src);
const initialPage = initialView.page;
- // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- Own the PDF fetch, load timeout, and pdf.js document task across source changes, retries, and unmounts.
+ // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- Own the PDF fetch, load timeout, and pdf.js document task across retries, range fallbacks, and unmounts; the caller remounts for a new source.
useEffect(() => {
const controller = new AbortController();
let disposed = false;
@@ -179,15 +199,28 @@ export default function PdfViewer(props: {
controller.abort();
void task?.destroy();
}, 30_000);
- void readBoundedDocument(
- props.src,
- controller.signal,
- 50 * 1024 * 1024,
- revision > 0 ? "reload" : "default",
- )
- .then(async (bytes) => {
+ const limit = 50 * 1024 * 1024;
+ void (async () => {
+ const ranges = fullRead
+ ? null
+ : await openPdfRanges(currentSrc, controller.signal, limit, () => {
+ keepView();
+ setPdf(null);
+ setFullRead(true);
+ });
+ return (
+ ranges ??
+ (await readBoundedDocument(
+ currentSrc(),
+ controller.signal,
+ limit,
+ revision > 0 || fullRead ? "reload" : "default",
+ ))
+ );
+ })()
+ .then(async (source) => {
controller.signal.throwIfAborted();
- task = openPdf(bytes);
+ task = openPdf(source);
const document = await task.promise;
if (document.numPages > MAX_PAGES)
throw new Error(
@@ -223,7 +256,7 @@ export default function PdfViewer(props: {
clearTimeout(timeout);
void task?.destroy();
};
- }, [props.src, revision, initialPage, savedPosition]);
+ }, [revision, fullRead, initialPage, savedPosition]);
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- Measure the PDF viewport before paint and observe resizes for fit-width sizing and visible-page selection.
useLayoutEffect(() => {
const node = scroll.current;
@@ -232,8 +265,6 @@ export default function PdfViewer(props: {
update();
return observeResize(node, update);
}, []);
- const { scale, width } = pdfPageWidth(viewport.width, pageWidth, zoom);
- const offsets = pdfPageOffsets(ratios, width);
const current = currentPdfPage(offsets, ratios.length, scrollTop);
const visible = visiblePdfPages(ratios, offsets, scrollTop, viewport.height);
// Stable callbacks let page canvases survive scroll and find updates.
@@ -247,14 +278,8 @@ export default function PdfViewer(props: {
scroll.current?.scrollTo({ top: pdfPageScrollTop(offsets, index) });
});
const saveView = (node: HTMLDivElement, notify = true) => {
- const page = currentPdfPage(offsets, ratios.length, node.scrollTop);
if (!pdf) return;
- const view = {
- page,
- offset: Math.max(0, node.scrollTop - (offsets[page]! - 16)),
- zoom,
- left: node.scrollLeft,
- };
+ const view = readView(node);
if (notify) props.onViewChange?.(view);
if (props.positionKey !== undefined) {
positions.delete(props.positionKey);
@@ -267,7 +292,12 @@ export default function PdfViewer(props: {
const node = scroll.current;
if (!pdf || !node) return;
node.scrollTo({
- top: pdfRestoredScrollTop(ratios, width, initialView, savedPosition?.width),
+ top: pdfRestoredScrollTop(
+ ratios,
+ width,
+ initialView,
+ initialView.width ?? savedPosition?.width,
+ ),
left: initialView.left,
});
setScrollTop(node.scrollTop);
diff --git a/apps/web/src/components/files/pdfDocument.ts b/apps/web/src/components/files/pdfDocument.ts
index 32e8aefbe9028..6c1bb26f78324 100644
--- a/apps/web/src/components/files/pdfDocument.ts
+++ b/apps/web/src/components/files/pdfDocument.ts
@@ -1,6 +1,8 @@
-import { getDocument, GlobalWorkerOptions, PDFWorker } from "pdfjs-dist";
+import { getDocument, GlobalWorkerOptions, PDFDataRangeTransport, PDFWorker } from "pdfjs-dist";
import workerUrl from "pdfjs-dist/build/pdf.worker.min.mjs?url";
import fallbackUrl from "pdfjs-dist/wasm/openjpeg_nowasm_fallback.js?url";
+import { PreviewError } from "./previewFailure";
+import { readBoundedBody } from "./readBoundedDocument";
GlobalWorkerOptions.workerSrc = workerUrl;
@@ -34,11 +36,68 @@ export class BinaryDataFactory {
// Without a shared worker, pdf.js starts a worker and recompiles its 1.3 MB script for every document.
let worker: PDFWorker | undefined;
-export function openPdf(bytes: ArrayBuffer) {
+const RANGE_CHUNK_BYTES = 64 * 1024;
+
+async function readRange(src: string, begin: number, end: number, signal: AbortSignal) {
+ const response = await fetch(src, {
+ signal,
+ // A cached partial response makes the browser add If-Range, which the server answers in full.
+ cache: "no-store",
+ // Explicit offsets stay CORS-safelisted; suffix ranges need a preflight the server refuses.
+ headers: { range: `bytes=${begin}-${end - 1}` },
+ });
+ const match = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(response.headers.get("content-range") ?? "");
+ const size = Number(match?.[3]);
+ const length = Math.min(end, size) - begin;
+ const valid =
+ response.status === 206 &&
+ match &&
+ Number(match[1]) === begin &&
+ Number(match[2]) === begin + length - 1;
+ const bytes = valid ? await readBoundedBody(response, length).catch(() => null) : null;
+ if (!bytes || bytes.byteLength !== length) {
+ void response.body?.cancel().catch(() => undefined);
+ throw new Error("Invalid PDF range response.");
+ }
+ return { bytes: new Uint8Array(bytes), size, revision: response.headers.get("etag") };
+}
+
+/**
+ * Reads only the byte ranges PDF.js asks for. Resolves null when the source cannot
+ * serve validated ranges; `onFailure` reports a later bad range or revision change.
+ * `src` is read per request so later ranges use a renewed asset grant.
+ */
+export async function openPdfRanges(
+ src: () => string,
+ signal: AbortSignal,
+ limit: number,
+ onFailure: () => void,
+) {
+ const first = await readRange(src(), 0, RANGE_CHUNK_BYTES, signal).catch(() => null);
+ if (!first?.revision) return null;
+ if (first.size > limit) throw new PreviewError({ code: "document-too-large" });
+ const transport = new PDFDataRangeTransport(first.size, first.bytes);
+ transport.requestDataRange = (begin: number, end: number) => {
+ void readRange(src(), begin, end, signal)
+ .then((range) => {
+ if (range.size !== first.size || range.revision !== first.revision)
+ throw new Error("The PDF changed while loading.");
+ transport.onDataRange(begin, range.bytes);
+ })
+ .catch(() => {
+ if (!signal.aborted) onFailure();
+ });
+ };
+ return transport;
+}
+
+export function openPdf(source: ArrayBuffer | PDFDataRangeTransport) {
worker ??= new PDFWorker();
return getDocument({
worker,
- data: new Uint8Array(bytes),
+ ...(source instanceof ArrayBuffer
+ ? { data: new Uint8Array(source) }
+ : { range: source, rangeChunkSize: RANGE_CHUNK_BYTES, disableAutoFetch: true }),
useSystemFonts: true,
useWorkerFetch: false,
BinaryDataFactory,
diff --git a/apps/web/src/components/files/readBoundedDocument.ts b/apps/web/src/components/files/readBoundedDocument.ts
index 1a7312b875655..4247efc421f7f 100644
--- a/apps/web/src/components/files/readBoundedDocument.ts
+++ b/apps/web/src/components/files/readBoundedDocument.ts
@@ -1,14 +1,6 @@
import { PreviewError } from "./previewFailure";
-export async function readBoundedDocument(
- src: string,
- signal: AbortSignal,
- limit: number,
- cache: RequestCache = "default",
-) {
- const response = await fetch(src, { signal, cache });
- if (!response.ok || Number(response.headers.get("content-length")) > limit)
- throw new PreviewError({ code: "document-unavailable-or-too-large" });
+export async function readBoundedBody(response: Response, limit: number) {
const reader = response.body?.getReader();
if (!reader) throw new PreviewError({ code: "document-unavailable" });
const chunks: Uint8Array[] = [];
@@ -26,3 +18,15 @@ export async function readBoundedDocument(
}
return new Blob(chunks).arrayBuffer();
}
+
+export async function readBoundedDocument(
+ src: string,
+ signal: AbortSignal,
+ limit: number,
+ cache: RequestCache = "default",
+) {
+ const response = await fetch(src, { signal, cache });
+ if (!response.ok || Number(response.headers.get("content-length")) > limit)
+ throw new PreviewError({ code: "document-unavailable-or-too-large" });
+ return readBoundedBody(response, limit);
+}