@vryzel/file-next 0.5.2 → 0.6.0

package/dist/server/index.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { F as FileNode, M as MetadataStore, a as FileSystem, R as Result } from '../filesystem-Djiiu6YU.js';
+import { F as FileNode, M as MetadataStore, a as FileSystem, R as Result } from '../filesystem-CF4TFF58.js';
 import { FileSystemError } from '../errors/index.js';
-import { A as AuthContext } from '../with-auth-OZNiZGga.js';
+import { A as AuthContext } from '../with-auth-BvFHyioA.js';
 import { createWriteThrough } from '../sync/index.js';
 
 /**
@@ -13,150 +13,64 @@ declare const ListFilesInputSchema: z.ZodObject<{
     parentId: z.ZodNullable<z.ZodString>;
     limit: z.ZodOptional<z.ZodNumber>;
     cursor: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    parentId: string | null;
-    limit?: number | undefined;
-    cursor?: string | undefined;
-}, {
-    parentId: string | null;
-    limit?: number | undefined;
-    cursor?: string | undefined;
-}>;
+}, z.core.$strip>;
 declare const DeleteFileInputSchema: z.ZodObject<{
     id: z.ZodString;
     recursive: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    recursive?: boolean | undefined;
-}, {
-    id: string;
-    recursive?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 declare const MoveFileInputSchema: z.ZodObject<{
     id: z.ZodString;
     newParentId: z.ZodNullable<z.ZodString>;
     newName: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    newParentId: string | null;
-    newName?: string | undefined;
-}, {
-    id: string;
-    newParentId: string | null;
-    newName?: string | undefined;
-}>;
+}, z.core.$strip>;
 declare const CopyFileInputSchema: z.ZodObject<{
     id: z.ZodString;
     newParentId: z.ZodNullable<z.ZodString>;
     newName: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    newParentId: string | null;
-    newName?: string | undefined;
-}, {
-    id: string;
-    newParentId: string | null;
-    newName?: string | undefined;
-}>;
+}, z.core.$strip>;
 declare const SetMetadataInputSchema: z.ZodObject<{
     id: z.ZodString;
     metadata: z.ZodRecord<z.ZodString, z.ZodString>;
     replace: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    metadata: Record<string, string>;
-    replace?: boolean | undefined;
-}, {
-    id: string;
-    metadata: Record<string, string>;
-    replace?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 declare const CreateFolderInputSchema: z.ZodObject<{
     parentId: z.ZodNullable<z.ZodString>;
     name: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    parentId: string | null;
-    name: string;
-}, {
-    parentId: string | null;
-    name: string;
-}>;
+}, z.core.$strip>;
 declare const PrepareUploadInputSchema: z.ZodObject<{
     parentId: z.ZodNullable<z.ZodString>;
     name: z.ZodString;
     contentType: z.ZodString;
     contentLength: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    parentId: string | null;
-    name: string;
-    contentType: string;
-    contentLength: number;
-}, {
-    parentId: string | null;
-    name: string;
-    contentType: string;
-    contentLength: number;
-}>;
+}, z.core.$strip>;
 declare const ConfirmUploadInputSchema: z.ZodObject<{
     id: z.ZodString;
     parentId: z.ZodNullable<z.ZodString>;
     name: z.ZodString;
     contentType: z.ZodOptional<z.ZodString>;
     size: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    parentId: string | null;
-    id: string;
-    name: string;
-    contentType?: string | undefined;
-    size?: number | undefined;
-}, {
-    parentId: string | null;
-    id: string;
-    name: string;
-    contentType?: string | undefined;
-    size?: number | undefined;
-}>;
+}, z.core.$strip>;
 declare const SearchFilesInputSchema: z.ZodObject<{
     query: z.ZodString;
     parentId: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    query: string;
-    parentId?: string | undefined;
-    limit?: number | undefined;
-}, {
-    query: string;
-    parentId?: string | undefined;
-    limit?: number | undefined;
-}>;
+}, z.core.$strip>;
+declare const ListTrashInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 declare const RestoreNodeInputSchema: z.ZodObject<{
     id: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-}, {
-    id: string;
-}>;
+}, z.core.$strip>;
 declare const CreateShareInputSchema: z.ZodObject<{
     id: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-}, {
-    id: string;
-}>;
+}, z.core.$strip>;
 declare const ResolveShareInputSchema: z.ZodObject<{
     token: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    token: string;
-}, {
-    token: string;
-}>;
+}, z.core.$strip>;
 declare const RevokeShareInputSchema: z.ZodObject<{
     token: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    token: string;
-}, {
-    token: string;
-}>;
+}, z.core.$strip>;
 interface ServerActionsDeps {
     readonly store: MetadataStore;
     readonly writeThrough: CreateWriteThrough;
@@ -164,6 +78,10 @@ interface ServerActionsDeps {
     readonly getAuth: () => AuthContext | Promise<AuthContext>;
     /** App path prefix for share links. Default `/api/share`. */
     readonly sharePathPrefix?: string;
+    /** Per-object cap for `prepareUpload`. Falls back to `fs.maxBytes`. */
+    readonly maxBytes?: number;
+    /** Literals (`image/png`) or wildcards (`image/*`). SVG is never allowed. */
+    readonly allowedContentTypes?: ReadonlyArray<string>;
 }
 declare const createServerActions: (deps: ServerActionsDeps) => {
     listFiles: (input: z.infer<typeof ListFilesInputSchema>) => Promise<Result<ListFilesOutput, FileSystemError>>;
@@ -175,10 +93,7 @@ declare const createServerActions: (deps: ServerActionsDeps) => {
     prepareUpload: (input: z.infer<typeof PrepareUploadInputSchema>) => Promise<Result<PrepareUploadOutput, FileSystemError>>;
     confirmUpload: (input: z.infer<typeof ConfirmUploadInputSchema>) => Promise<Result<FileNode, FileSystemError>>;
     searchFiles: (input: z.infer<typeof SearchFilesInputSchema>) => Promise<Result<ListFilesOutput, FileSystemError>>;
-    listTrash: (input?: {
-        limit?: number;
-        cursor?: string;
-    }) => Promise<Result<ListFilesOutput, FileSystemError>>;
+    listTrash: (input?: z.infer<typeof ListTrashInputSchema>) => Promise<Result<ListFilesOutput, FileSystemError>>;
     restoreNode: (input: z.infer<typeof RestoreNodeInputSchema>) => Promise<Result<FileNode, FileSystemError>>;
     purgeNode: (input: z.infer<typeof RestoreNodeInputSchema>) => Promise<Result<void, FileSystemError>>;
     createShare: (input: z.infer<typeof CreateShareInputSchema>) => Promise<Result<{
@@ -203,8 +118,10 @@ interface PrepareUploadOutput {
 
 interface CreateUploadRouteHandlerOptions {
     readonly fs: FileSystem;
-    /** Resolve the caller. 401 when it returns null. */
+    /** Resolve the caller. Required unless `unsafeNoAuth` is set. */
     readonly getAuth?: (req: Request) => Promise<AuthContext | null>;
+    /** Explicit opt-in for a handler that signs without a caller. */
+    readonly unsafeNoAuth?: boolean;
     /** Reject requests whose `contentLength` exceeds this. Omit for no cap. */
     readonly maxBytes?: number;
     /**
@@ -234,7 +151,12 @@ declare const createUploadRouteHandler: (opts: CreateUploadRouteHandlerOptions)
 
 interface CreateDownloadRouteHandlerOptions {
     readonly fs: FileSystem;
+    /** Required unless `unsafeNoAuth` is set. */
     readonly getAuth?: (req: Request) => Promise<AuthContext | null>;
+    /** Explicit opt-in for a handler that signs without a caller. */
+    readonly unsafeNoAuth?: boolean;
+    /** Required with `getAuth`. Signs only a live node key for that tenant. */
+    readonly store?: MetadataStore;
     /** Presigned URL lifetime in seconds. Default 900, max 7d (S3 SigV4). */
     readonly expiresIn?: number;
 }
@@ -256,6 +178,8 @@ declare const createDownloadRouteHandler: (opts: CreateDownloadRouteHandlerOptio
 interface CreateShareRouteHandlerOptions {
     readonly store: MetadataStore;
     readonly fs: FileSystem;
+    /** Bytes buffered through the app. Larger objects redirect to a 60s signed URL. */
+    readonly maxBytes?: number;
 }
 declare const createShareRouteHandler: (opts: CreateShareRouteHandlerOptions) => ((req: Request) => Promise<Response>);
 

package/dist/server/index.js

@@ -158,13 +158,44 @@ var FileSystemError = class extends Error {
 var asS3Key = (s) => s;
 var asTenantId = (s) => s;
 
+// src/storage/content-disposition.ts
+var NEVER_INLINE = /* @__PURE__ */ new Set(["text/html", "application/xhtml+xml", "image/svg+xml"]);
+var DENIED_UPLOAD = /* @__PURE__ */ new Set([
+  "text/html",
+  "application/xhtml+xml",
+  "image/svg+xml",
+  "text/xml",
+  "application/xml"
+]);
+function mimeBase(contentType) {
+  return (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+}
+function isDeniedUploadType(contentType) {
+  return DENIED_UPLOAD.has(mimeBase(contentType));
+}
+function matchesAllowedContentType(pattern, actual) {
+  const mime = mimeBase(actual);
+  if (!mime || isDeniedUploadType(mime)) return false;
+  if (pattern === mime) return true;
+  if (pattern.endsWith("/*")) return mime.startsWith(pattern.slice(0, -1));
+  return false;
+}
+function signedContentDisposition(requested, contentType) {
+  const mime = (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+  if (!mime || NEVER_INLINE.has(mime)) return "attachment";
+  if (mime === "application/pdf" || mime === "text/plain" || mime === "text/csv" || mime === "text/markdown" || mime.startsWith("image/") || mime.startsWith("video/") || mime.startsWith("audio/")) {
+    return "inline";
+  }
+  return "attachment";
+}
+
 // src/server/actions.ts
 var NodeIdSchema = z.string().min(1, "id is required");
 var PathSchema = z.string().nullable();
 var ListFilesInputSchema = z.object({
   parentId: PathSchema,
-  limit: z.number().int().positive().optional(),
-  cursor: z.string().optional()
+  limit: z.number().int().positive().max(500).optional(),
+  cursor: z.string().max(256).optional()
 });
 var DeleteFileInputSchema = z.object({
   id: NodeIdSchema,
@@ -182,7 +213,7 @@ var CopyFileInputSchema = z.object({
 });
 var SetMetadataInputSchema = z.object({
   id: NodeIdSchema,
-  metadata: z.record(z.string()),
+  metadata: z.record(z.string(), z.string()),
   replace: z.boolean().optional()
 });
 var CreateFolderInputSchema = z.object({
@@ -203,9 +234,13 @@ var ConfirmUploadInputSchema = z.object({
   size: z.number().int().nonnegative().optional()
 });
 var SearchFilesInputSchema = z.object({
-  query: z.string(),
-  parentId: z.string().optional(),
-  limit: z.number().int().positive().optional()
+  query: z.string().max(256),
+  parentId: z.string().max(256).optional(),
+  limit: z.number().int().positive().max(500).optional()
+});
+var ListTrashInputSchema = z.object({
+  limit: z.number().int().positive().max(500).optional(),
+  cursor: z.string().max(256).optional()
 });
 var RestoreNodeInputSchema = z.object({
   id: NodeIdSchema
@@ -234,7 +269,7 @@ var createServerActions = (deps) => {
     if (e instanceof FileSystemError) return e;
     return new FileSystemError({
       code,
-      message: `${message}: ${e instanceof Error ? e.message : String(e)}`,
+      message,
       retryable: true
     });
   };
@@ -335,12 +370,34 @@ var createServerActions = (deps) => {
   const prepareUpload = async (input) => {
     const parsed = PrepareUploadInputSchema.safeParse(input);
     if (!parsed.success) return zodErr("Invalid prepareUpload input", parsed);
+    const maxBytes = deps.maxBytes ?? fs.maxBytes;
+    if (maxBytes != null && parsed.data.contentLength > maxBytes) {
+      return err(
+        new FileSystemError({
+          code: "PayloadTooLarge",
+          message: `contentLength exceeds maxBytes ${maxBytes}`,
+          retryable: false
+        })
+      );
+    }
+    if (isDeniedUploadType(parsed.data.contentType) || deps.allowedContentTypes != null && !deps.allowedContentTypes.some(
+      (pattern) => matchesAllowedContentType(pattern, parsed.data.contentType)
+    )) {
+      return err(
+        new FileSystemError({
+          code: "UnsupportedMediaType",
+          message: "Content type is not allowed",
+          retryable: false
+        })
+      );
+    }
     try {
       const auth = await authTenant();
       const id = typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : `upl-${Date.now()}`;
       const signed = await fs.forTenant(auth.tenantId).adapter.createPresignedUploadUrl({
         key: asS3Key(id),
         contentType: parsed.data.contentType,
+        contentLength: parsed.data.contentLength,
         expiresIn: 900
       });
       if (!signed.ok) return signed;
@@ -390,12 +447,14 @@ var createServerActions = (deps) => {
     }
   };
   const listTrash = async (input = {}) => {
+    const parsed = ListTrashInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid listTrash input", parsed);
     try {
       const auth = await authTenant();
       return store.listTrash({
         tenantId: asTenantId(auth.tenantId),
-        limit: input.limit,
-        cursor: input.cursor
+        limit: parsed.data.limit,
+        cursor: parsed.data.cursor
       });
     } catch (e) {
       return err(wrap(e, "InternalError", "listTrash failed"));
@@ -497,18 +556,12 @@ var createServerActions = (deps) => {
     revokeShare
   };
 };
-
-// src/server/route-handlers/upload.ts
 var MAX_EXPIRES_IN_SECONDS = 7 * 24 * 60 * 60;
 var DEFAULT_EXPIRES_IN_SECONDS = 900;
-var matchesContentType = (pattern, actual) => {
-  if (pattern === actual) return true;
-  if (pattern.endsWith("/*")) {
-    const prefix = pattern.slice(0, -1);
-    return actual.startsWith(prefix);
-  }
-  return false;
-};
+var UploadBody = z.object({
+  contentType: z.string().min(1).max(255),
+  contentLength: z.number().int().nonnegative()
+});
 var assertExpiresIn = (expiresIn) => {
   if (!Number.isFinite(expiresIn) || expiresIn < 1 || expiresIn > MAX_EXPIRES_IN_SECONDS) {
     throw new FileSystemError({
@@ -520,65 +573,76 @@ var assertExpiresIn = (expiresIn) => {
   }
 };
 var createUploadRouteHandler = (opts) => {
+  if (!opts.getAuth && opts.unsafeNoAuth !== true) {
+    throw new Error("file-next: getAuth is required");
+  }
   const expiresIn = opts.expiresIn ?? DEFAULT_EXPIRES_IN_SECONDS;
   assertExpiresIn(expiresIn);
   return async (req) => {
-    let body;
+    let fs = opts.fs;
+    if (opts.getAuth) {
+      const auth = await opts.getAuth(req);
+      if (!auth) {
+        return Response.json(
+          { ok: false, error: { code: "Unauthorized", message: "Not authenticated" } },
+          { status: 401 }
+        );
+      }
+      fs = opts.fs.forTenant(auth.tenantId);
+    }
+    let raw;
     try {
-      body = await req.json();
+      raw = await req.json();
     } catch {
       return Response.json(
         { ok: false, error: { code: "InternalError", message: "Request body must be valid JSON" } },
         { status: 400 }
       );
     }
+    const parsed = UploadBody.safeParse(raw);
+    if (!parsed.success) {
+      return Response.json(
+        { ok: false, error: { code: "InternalError", message: "Invalid upload request" } },
+        { status: 400 }
+      );
+    }
+    const body = parsed.data;
     if (typeof opts.maxBytes === "number" && body.contentLength > opts.maxBytes) {
       return Response.json(
         {
           ok: false,
           error: {
             code: "PayloadTooLarge",
-            message: `contentLength ${body.contentLength} exceeds maxBytes ${opts.maxBytes}`
+            message: `contentLength exceeds maxBytes ${opts.maxBytes}`
           }
         },
         { status: 413 }
       );
     }
-    if (opts.allowedContentTypes && opts.allowedContentTypes.length > 0) {
-      const allowed = opts.allowedContentTypes.some((p) => matchesContentType(p, body.contentType));
-      if (!allowed) {
-        return Response.json(
-          {
-            ok: false,
-            error: {
-              code: "UnsupportedMediaType",
-              message: `contentType "${body.contentType}" is not in the allowed list`
-            }
-          },
-          { status: 415 }
-        );
-      }
-    }
-    let fs = opts.fs;
-    if (opts.getAuth) {
-      const auth = await opts.getAuth(req);
-      if (!auth) {
-        return Response.json(
-          { ok: false, error: { code: "Unauthorized", message: "Not authenticated" } },
-          { status: 401 }
-        );
-      }
-      fs = opts.fs.forTenant(auth.tenantId);
+    if (isDeniedUploadType(body.contentType) || opts.allowedContentTypes && opts.allowedContentTypes.length > 0 && !opts.allowedContentTypes.some(
+      (pattern) => matchesAllowedContentType(pattern, body.contentType)
+    )) {
+      return Response.json(
+        {
+          ok: false,
+          error: {
+            code: "UnsupportedMediaType",
+            message: "Content type is not allowed"
+          }
+        },
+        { status: 415 }
+      );
     }
     const id = typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : `upl-${Date.now()}`;
     const r = await fs.adapter.createPresignedUploadUrl({
       key: asS3Key(id),
       contentType: body.contentType,
+      contentLength: body.contentLength,
       expiresIn
     });
     if (!r.ok) {
       return Response.json(
-        { ok: false, error: { code: r.error.code, message: r.error.message } },
+        { ok: false, error: { code: r.error.code, message: "Upload failed" } },
         { status: 500 }
       );
     }
@@ -611,9 +675,28 @@ var assertExpiresIn2 = (expiresIn) => {
   }
 };
 var createDownloadRouteHandler = (opts) => {
+  if (!opts.getAuth && opts.unsafeNoAuth !== true) {
+    throw new Error("file-next: getAuth is required");
+  }
+  if (opts.getAuth && !opts.store) {
+    throw new Error("file-next: store is required when getAuth is set");
+  }
   const expiresIn = opts.expiresIn ?? DEFAULT_EXPIRES_IN_SECONDS2;
   assertExpiresIn2(expiresIn);
   return async (req) => {
+    let fs = opts.fs;
+    let tenantId;
+    if (opts.getAuth) {
+      const auth = await opts.getAuth(req);
+      if (!auth) {
+        return Response.json(
+          { ok: false, error: { code: "Unauthorized", message: "Not authenticated" } },
+          { status: 401 }
+        );
+      }
+      tenantId = auth.tenantId;
+      fs = opts.fs.forTenant(auth.tenantId);
+    }
     const url = new URL(req.url);
     const key = url.searchParams.get("key");
     if (!key) {
@@ -622,16 +705,17 @@ var createDownloadRouteHandler = (opts) => {
         { status: 400 }
       );
     }
-    let fs = opts.fs;
-    if (opts.getAuth) {
-      const auth = await opts.getAuth(req);
-      if (!auth) {
+    if (opts.store && tenantId) {
+      const node = await opts.store.findByS3Key({
+        tenantId: asTenantId(tenantId),
+        s3Key: key
+      });
+      if (!node.ok || !node.value) {
         return Response.json(
-          { ok: false, error: { code: "Unauthorized", message: "Not authenticated" } },
-          { status: 401 }
+          { ok: false, error: { code: "NotFound", message: "Not found" } },
+          { status: 404 }
         );
       }
-      fs = opts.fs.forTenant(auth.tenantId);
     }
     const r = await fs.adapter.createPresignedDownloadUrl({
       key: asS3Key(key),
@@ -639,7 +723,7 @@ var createDownloadRouteHandler = (opts) => {
     });
     if (!r.ok) {
       return Response.json(
-        { ok: false, error: { code: r.error.code, message: r.error.message } },
+        { ok: false, error: { code: r.error.code, message: "Download failed" } },
         { status: 500 }
       );
     }
@@ -651,18 +735,17 @@ var createDownloadRouteHandler = (opts) => {
   };
 };
 
-// src/storage/content-disposition.ts
-var NEVER_INLINE = /* @__PURE__ */ new Set(["text/html", "application/xhtml+xml", "image/svg+xml"]);
-function signedContentDisposition(requested, contentType) {
-  const mime = (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
-  if (!mime || NEVER_INLINE.has(mime)) return "attachment";
-  if (mime === "application/pdf" || mime === "text/plain" || mime === "text/csv" || mime === "text/markdown" || mime.startsWith("image/") || mime.startsWith("video/") || mime.startsWith("audio/")) {
-    return "inline";
-  }
-  return "attachment";
-}
-
 // src/server/route-handlers/share.ts
+var DEFAULT_MAX_SHARE_BYTES = 32 * 1024 * 1024;
+var shareHeaders = () => {
+  const headers = new Headers();
+  headers.set("X-Content-Type-Options", "nosniff");
+  headers.set("Content-Security-Policy", "sandbox; default-src 'none'");
+  headers.set("Cross-Origin-Resource-Policy", "same-origin");
+  headers.set("Cache-Control", "private, no-store");
+  headers.set("Referrer-Policy", "no-referrer");
+  return headers;
+};
 var tokenFromRequest = (req) => {
   const url = new URL(req.url);
   const query = url.searchParams.get("token");
@@ -684,7 +767,7 @@ var createShareRouteHandler = (opts) => {
     const resolved = await opts.store.resolveShare({ token });
     if (!resolved.ok) {
       return Response.json(
-        { ok: false, error: { code: resolved.error.code, message: resolved.error.message } },
+        { ok: false, error: { code: "InternalError", message: "Share lookup failed" } },
         { status: 500 }
       );
     }
@@ -696,29 +779,54 @@ var createShareRouteHandler = (opts) => {
       );
     }
     const adapter = opts.fs.forTenant(node.tenantId).adapter;
-    const rangeHeader = req.headers.get("range") ?? void 0;
+    const download = new URL(req.url).searchParams.get("download") === "1";
+    const key = asS3Key(node.s3Key);
+    const st = await adapter.stat({ key });
+    if (!st.ok) {
+      return Response.json(
+        { ok: false, error: { code: "NotFound", message: "Share not found" } },
+        { status: 404 }
+      );
+    }
+    const maxBytes = opts.maxBytes ?? DEFAULT_MAX_SHARE_BYTES;
+    if (st.value.size > maxBytes) {
+      const signed = await adapter.createPresignedDownloadUrl({
+        key,
+        expiresIn: 60,
+        disposition: download ? "attachment" : "inline",
+        contentType: st.value.contentType || node.mimeType
+      });
+      if (!signed.ok) {
+        return Response.json(
+          { ok: false, error: { code: "InternalError", message: "Share failed" } },
+          { status: 500 }
+        );
+      }
+      const headers2 = shareHeaders();
+      headers2.set("Location", signed.value.url);
+      return new Response(null, { status: 302, headers: headers2 });
+    }
     const read = await adapter.read({
-      key: asS3Key(node.s3Key),
-      range: rangeHeader ?? void 0
+      key,
+      range: req.headers.get("range") ?? void 0
     });
     if (!read.ok) {
       return Response.json(
-        { ok: false, error: { code: read.error.code, message: read.error.message } },
+        { ok: false, error: { code: "NotFound", message: "Share not found" } },
         { status: 404 }
       );
     }
-    const download = new URL(req.url).searchParams.get("download") === "1";
-    const headers = new Headers();
-    const mime = node.mimeType || read.value.contentType || "application/octet-stream";
+    const headers = shareHeaders();
+    const mime = st.value.contentType || node.mimeType || read.value.contentType || "application/octet-stream";
     headers.set("Content-Type", mime);
     const disposition = download ? "attachment" : signedContentDisposition("inline", mime);
     headers.set(
       "Content-Disposition",
       `${disposition}; filename*=UTF-8''${encodeURIComponent(node.name)}`
     );
-    headers.set("Cache-Control", "private, no-store");
-    headers.set("Content-Length", String(read.value.body.byteLength));
-    return new Response(Buffer.from(read.value.body), { status: 200, headers });
+    const bytes = Uint8Array.from(read.value.body);
+    headers.set("Content-Length", String(bytes.byteLength));
+    return new Response(bytes.buffer, { status: 200, headers });
   };
 };