@suphark/files-client 0.0.0-stage → 0.3.0

package/dist/next/index.js

@@ -0,0 +1,186 @@
+import {
+  createPiFiles
+} from "../chunk-5VLU7KXC.js";
+import {
+  PiFilesError,
+  buildUrl,
+  resolveAuthHeader
+} from "../chunk-YZSJOMM6.js";
+
+// src/core/webhooks.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function verifyWebhookSignature(body, header, secret, { toleranceSeconds = 300, now = Date.now() } = {}) {
+  if (!header) return false;
+  const parts = Object.fromEntries(header.split(",").map((p) => p.split("=")));
+  const t = Number(parts.t);
+  if (!Number.isFinite(t) || !parts.v1) return false;
+  if (Math.abs(now / 1e3 - t) > toleranceSeconds) return false;
+  const expected = Buffer.from(createHmac("sha256", secret).update(`${t}.${body}`).digest("hex"));
+  const actual = Buffer.from(parts.v1);
+  return expected.length === actual.length && timingSafeEqual(expected, actual);
+}
+
+// src/next/index.ts
+function createPiFilesNext(config) {
+  const { client } = config;
+  function content(opts) {
+    return async (request, ctx) => {
+      const params = await ctx.params;
+      const target = await opts.resolve(request, params);
+      if (target === null) return new Response(null, { status: 404 });
+      if (target instanceof Response) return target;
+      const strategy = opts.strategy ?? "redirect";
+      try {
+        if (strategy === "redirect") {
+          const { url } = await client.files.contentUrl(target.fileId, {
+            download: target.download
+          });
+          return new Response(null, {
+            status: 302,
+            headers: { location: url, "cache-control": "private, no-store" }
+          });
+        }
+        const upstream = await client.files.stream(target.fileId, {
+          range: request.headers.get("range"),
+          download: target.download,
+          signal: request.signal
+        });
+        if (!upstream.ok && upstream.status !== 206) {
+          return new Response(null, { status: upstream.status === 404 ? 404 : 502 });
+        }
+        const headers = new Headers();
+        for (const name of [
+          "content-type",
+          "content-length",
+          "content-range",
+          "accept-ranges",
+          "etag",
+          "last-modified",
+          "content-disposition"
+        ]) {
+          const v = upstream.headers.get(name);
+          if (v) headers.set(name, v);
+        }
+        headers.set("cache-control", "private, max-age=3600");
+        return new Response(upstream.body, { status: upstream.status, headers });
+      } catch (error) {
+        if (error instanceof PiFilesError && error.status === 404)
+          return new Response(null, { status: 404 });
+        console.error("[pi-files] content proxy", error);
+        return new Response(null, { status: 502 });
+      }
+    };
+  }
+  function preview(opts) {
+    return async (request, ctx) => {
+      const params = await ctx.params;
+      const target = await opts.resolve(request, params);
+      if (target === null) return new Response(null, { status: 404 });
+      if (target instanceof Response) return target;
+      const size = new URL(request.url).searchParams.get("size") === "lg" ? "lg" : "sm";
+      try {
+        const upstream = await client.files.preview(target.fileId, {
+          size,
+          signal: request.signal
+        });
+        if (!upstream.ok)
+          return new Response(null, { status: upstream.status === 404 ? 404 : 502 });
+        const headers = new Headers({ "content-type": "image/webp" });
+        for (const name of ["content-length", "cache-control"]) {
+          const v = upstream.headers.get(name);
+          if (v) headers.set(name, v);
+        }
+        return new Response(upstream.body, { status: 200, headers });
+      } catch (error) {
+        if (error instanceof PiFilesError && error.status === 404)
+          return new Response(null, { status: 404 });
+        console.error("[pi-files] preview proxy", error);
+        return new Response(null, { status: 502 });
+      }
+    };
+  }
+  function uploads(opts) {
+    async function handle(request, ctx) {
+      const params = await ctx.params;
+      const raw = params.path;
+      const path = Array.isArray(raw) ? raw : raw ? [raw] : [];
+      const [uploadId, sub] = path;
+      const json = (body, status = 200) => new Response(JSON.stringify(body), {
+        status,
+        headers: { "content-type": "application/json", "cache-control": "no-store" }
+      });
+      const proxyError = (error) => {
+        if (error instanceof PiFilesError) {
+          const res = json(
+            error.problem ?? { code: error.code, detail: error.message },
+            error.status
+          );
+          const retryAfter = error.problem?.retryAfterSeconds;
+          if (error.status === 429 && retryAfter)
+            res.headers.set("retry-after", String(retryAfter));
+          return res;
+        }
+        console.error("[pi-files] uploads proxy", error);
+        return json({ code: "INTERNAL", detail: "Pi Files proxy error" }, 502);
+      };
+      try {
+        if (request.method === "POST" && path.length === 0) {
+          const body = await request.json().catch(() => ({}));
+          const auth = await opts.authorize(request, { kind: "create", body });
+          if (auth === null) return json({ code: "UNAUTHENTICATED" }, 401);
+          if (auth instanceof Response) return auth;
+          const uploadOrigin = request.headers.get("origin") ?? void 0;
+          const input = { uploadOrigin, ...body, ...auth.input };
+          return json(await client.uploads.create(input), 201);
+        }
+        if (uploadId === "replace" && sub && request.method === "POST" && path.length === 2) {
+          const body = await request.json().catch(() => ({}));
+          const auth = await opts.authorize(request, { kind: "replace", fileId: sub, body });
+          if (auth === null) return json({ code: "UNAUTHENTICATED" }, 401);
+          if (auth instanceof Response) return auth;
+          const uploadOrigin = request.headers.get("origin") ?? void 0;
+          const input = { uploadOrigin, ...body };
+          return json(await client.files.replace(sub, input), 201);
+        }
+        if (uploadId && request.method === "POST" && sub === "parts") {
+          const auth = await opts.authorize(request, { kind: "parts", uploadId });
+          if (auth === null) return json({ code: "UNAUTHENTICATED" }, 401);
+          if (auth instanceof Response) return auth;
+          const body = await request.json();
+          return json(await client.uploads.partUrls(uploadId, body.partNumbers));
+        }
+        if (uploadId && request.method === "POST" && sub === "complete") {
+          const auth = await opts.authorize(request, { kind: "complete", uploadId });
+          if (auth === null) return json({ code: "UNAUTHENTICATED" }, 401);
+          if (auth instanceof Response) return auth;
+          const body = await request.json().catch(() => ({}));
+          return json(await client.uploads.complete(uploadId, body.parts));
+        }
+        if (uploadId && request.method === "DELETE" && !sub) {
+          const auth = await opts.authorize(request, { kind: "abort", uploadId });
+          if (auth === null) return json({ code: "UNAUTHENTICATED" }, 401);
+          if (auth instanceof Response) return auth;
+          await client.uploads.abort(uploadId);
+          return json({ ok: true });
+        }
+        return json({ code: "NOT_FOUND" }, 404);
+      } catch (error) {
+        return proxyError(error);
+      }
+    }
+    return { POST: handle, DELETE: handle };
+  }
+  return {
+    client,
+    handlers: { content, preview, uploads },
+    /** header สำหรับเรียก Pi Files เองจาก server code ของ consumer */
+    authHeader: () => resolveAuthHeader(client.options),
+    url: (path) => buildUrl(client.options.baseUrl, path)
+  };
+}
+export {
+  PiFilesError,
+  createPiFiles,
+  createPiFilesNext,
+  verifyWebhookSignature
+};

package/dist/react/index.d.ts

@@ -0,0 +1,140 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { FileAssetDto, CreateUploadInput, UploadTicket } from '@pi/files-contracts';
+import { U as UploadProgress, P as PiFilesError } from '../upload-D79TA4qU.js';
+import { UploadApi } from '../index.js';
+
+/**
+ * ฝั่ง browser คุยกับ "endpoint" ที่มีรูปแบบเดียวกับ Pi Files:
+ *   POST {endpoint}            → ticket
+ *   POST {endpoint}/:id/parts  → part URLs
+ *   POST {endpoint}/:id/complete
+ *   DELETE {endpoint}/:id
+ * endpoint = "/api/files/uploads" ของ consumer (proxy ด้วย app key ผ่าน handlers.uploads)
+ * หรือ "/api/v1/uploads" ของ Pi Files เอง (cookie session)
+ */
+interface UploadEndpointOptions {
+    endpoint: string;
+    headers?: Record<string, string> | (() => Record<string, string>);
+    credentials?: RequestCredentials;
+}
+declare function PiFilesProvider({ children, ...opts }: UploadEndpointOptions & {
+    children: ReactNode;
+}): react.JSX.Element;
+declare function createEndpointApi(opts: UploadEndpointOptions): UploadApi & {
+    create: (input: CreateUploadInput) => Promise<UploadTicket>;
+};
+type UploadStatus = "idle" | "uploading" | "done" | "error" | "aborted";
+interface UseUploadOptions extends Partial<UploadEndpointOptions> {
+    onProgress?: (p: UploadProgress) => void;
+    concurrency?: number;
+}
+/** อัปโหลดไฟล์เดียว พร้อม progress / cancel / resume (multipart ที่ค้างจากรอบก่อน) */
+declare function useUpload(options?: UseUploadOptions): {
+    upload: (file: File, input?: Omit<CreateUploadInput, "filename" | "mimeType" | "sizeBytes">) => Promise<{
+        id: string;
+        filename: string;
+        mimeType: string;
+        sizeBytes: string;
+        status: "UPLOADING" | "ACTIVE" | "ORPHAN_CANDIDATE" | "TRASHED" | "PENDING_DELETE" | "MISSING" | "DELETED" | "ERROR";
+        visibility: "PRIVATE" | "TENANT" | "PUBLIC";
+        ownerType: "USER" | "APP";
+        ownerId: string;
+        appKey: string | null;
+        folderId: string | null;
+        etag: string | null;
+        checksumSha256: string | null;
+        versionCount: number;
+        refCount: number;
+        metadata: Record<string, unknown>;
+        createdById: string | null;
+        createdAt: string;
+        updatedAt: string;
+        trashedAt: string | null;
+        contentPath: string;
+        previewPath: string | null;
+        publicUrl: string | null;
+        storage: {
+            bucketKey: string;
+            bucketLabel: string | null;
+            kind: string;
+            providerName: string;
+            sourceUrl?: string | null | undefined;
+            linked?: boolean | undefined;
+        } | null;
+    }>;
+    cancel: () => void | undefined;
+    status: UploadStatus;
+    progress: UploadProgress;
+    error: PiFilesError | null;
+    result: {
+        id: string;
+        filename: string;
+        mimeType: string;
+        sizeBytes: string;
+        status: "UPLOADING" | "ACTIVE" | "ORPHAN_CANDIDATE" | "TRASHED" | "PENDING_DELETE" | "MISSING" | "DELETED" | "ERROR";
+        visibility: "PRIVATE" | "TENANT" | "PUBLIC";
+        ownerType: "USER" | "APP";
+        ownerId: string;
+        appKey: string | null;
+        folderId: string | null;
+        etag: string | null;
+        checksumSha256: string | null;
+        versionCount: number;
+        refCount: number;
+        metadata: Record<string, unknown>;
+        createdById: string | null;
+        createdAt: string;
+        updatedAt: string;
+        trashedAt: string | null;
+        contentPath: string;
+        previewPath: string | null;
+        publicUrl: string | null;
+        storage: {
+            bucketKey: string;
+            bucketLabel: string | null;
+            kind: string;
+            providerName: string;
+            sourceUrl?: string | null | undefined;
+            linked?: boolean | undefined;
+        } | null;
+    } | null;
+};
+interface QueueItem {
+    id: string;
+    file: File;
+    status: UploadStatus;
+    progress: UploadProgress;
+    error: PiFilesError | null;
+    result: FileAssetDto | null;
+}
+/** คิวอัปโหลดหลายไฟล์ (ทีละ N ไฟล์) — ใช้กับ upload panel */
+declare function useUploadQueue(options?: UseUploadOptions & {
+    parallel?: number;
+}): {
+    items: QueueItem[];
+    enqueue: (files: File[], input?: Partial<CreateUploadInput>) => string[];
+    cancel: (id: string) => void;
+    clearFinished: () => void;
+};
+interface UseReplaceOptions extends UseUploadOptions {
+    /**
+     * URL ที่คืน ticket ของ replace ต่อไฟล์ — ค่าเริ่มต้น: endpoint ของ Pi Files (`…/api/v1/uploads`) → `/api/v1/files/:id/replace`,
+     * endpoint อื่น (proxy `handlers.uploads` ของ consumer) → `<endpoint>/replace/:id`
+     */
+    replaceUrl?: (fileId: string) => string;
+}
+/**
+ * อัปโหลดเวอร์ชันใหม่ทับไฟล์เดิม (id/ชื่อ/แชร์/reference คงเดิม; ฉบับเดิมเป็นประวัติ) พร้อม progress / cancel
+ * bytes + complete ใช้ endpoint เดียวกับ `useUpload` (ค่าเริ่มต้นของ context)
+ */
+declare function useReplace(options?: UseReplaceOptions): {
+    replace: (fileId: string, file: File) => Promise<FileAssetDto>;
+    cancel: () => void | undefined;
+    status: UploadStatus;
+    progress: UploadProgress;
+    error: PiFilesError | null;
+};
+
+export { PiFilesError, PiFilesProvider, UploadProgress, createEndpointApi, useReplace, useUpload, useUploadQueue };
+export type { QueueItem, UploadEndpointOptions, UploadStatus, UseReplaceOptions, UseUploadOptions };

package/dist/react/index.js

@@ -0,0 +1,357 @@
+"use client";
+import {
+  PiFilesError,
+  fetchWithRateLimitRetry,
+  fileFingerprint,
+  performUpload
+} from "../chunk-YZSJOMM6.js";
+
+// src/react/index.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var Ctx = createContext(null);
+function PiFilesProvider({
+  children,
+  ...opts
+}) {
+  const value = useMemo(() => opts, [opts.endpoint, opts.headers, opts.credentials]);
+  return /* @__PURE__ */ jsx(Ctx.Provider, { value, children });
+}
+async function endpointFetch(opts, path, init) {
+  const extra = typeof opts.headers === "function" ? opts.headers() : opts.headers ?? {};
+  const res = await fetchWithRateLimitRetry(fetch, `${opts.endpoint}${path}`, {
+    ...init,
+    credentials: opts.credentials ?? "include",
+    headers: {
+      "content-type": "application/json",
+      ...extra,
+      ...init.headers
+    }
+  });
+  if (!res.ok) {
+    const problem = await res.json().catch(() => ({}));
+    throw new PiFilesError(
+      res.status,
+      problem.code ?? `HTTP_${res.status}`,
+      problem.detail ?? problem.title ?? res.statusText
+    );
+  }
+  return await res.json();
+}
+function createEndpointApi(opts) {
+  return {
+    create: (input) => endpointFetch(opts, "", { method: "POST", body: JSON.stringify(input) }),
+    partUrls: (uploadId, partNumbers) => endpointFetch(opts, `/${uploadId}/parts`, {
+      method: "POST",
+      body: JSON.stringify({ partNumbers })
+    }),
+    complete: (uploadId, parts) => endpointFetch(opts, `/${uploadId}/complete`, {
+      method: "POST",
+      body: JSON.stringify({ parts })
+    }),
+    abort: (uploadId) => endpointFetch(opts, `/${uploadId}`, { method: "DELETE" }).then(() => void 0)
+  };
+}
+var RESUME_KEY = "pi-files:resume";
+function loadResume() {
+  try {
+    return JSON.parse(localStorage.getItem(RESUME_KEY) ?? "{}");
+  } catch {
+    return {};
+  }
+}
+function saveResume(all) {
+  try {
+    const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
+    for (const [k, v] of Object.entries(all)) if (v.savedAt < cutoff) delete all[k];
+    localStorage.setItem(RESUME_KEY, JSON.stringify(all));
+  } catch {
+  }
+}
+function useUpload(options = {}) {
+  const ctx = useContext(Ctx);
+  const endpoint = options.endpoint ?? ctx?.endpoint;
+  if (!endpoint) throw new Error("useUpload \u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 endpoint (prop \u0E2B\u0E23\u0E37\u0E2D <PiFilesProvider>)");
+  const api = useMemo(
+    () => createEndpointApi({
+      endpoint,
+      headers: options.headers ?? ctx?.headers,
+      credentials: options.credentials ?? ctx?.credentials
+    }),
+    [endpoint, options.headers, ctx?.headers, options.credentials, ctx?.credentials]
+  );
+  const [status, setStatus] = useState("idle");
+  const [progress, setProgress] = useState({ loaded: 0, total: 0, fraction: 0 });
+  const [error, setError] = useState(null);
+  const [result, setResult] = useState(null);
+  const abortRef = useRef(null);
+  const upload = useCallback(
+    async (file, input = {}) => {
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setStatus("uploading");
+      setError(null);
+      setResult(null);
+      const fp = fileFingerprint(file);
+      const resumeAll = loadResume();
+      let ticket;
+      let completedParts = [];
+      const cached = resumeAll[fp];
+      if (cached && cached.ticket.expiresAt > (/* @__PURE__ */ new Date()).toISOString()) {
+        ticket = cached.ticket;
+        completedParts = cached.parts;
+      } else {
+        ticket = await api.create({
+          ...input,
+          filename: file.name,
+          mimeType: file.type || "application/octet-stream",
+          sizeBytes: file.size
+        });
+        if (ticket.kind === "multipart") {
+          resumeAll[fp] = { ticket, parts: [], savedAt: Date.now() };
+          saveResume(resumeAll);
+        }
+      }
+      try {
+        const asset = await performUpload(
+          api,
+          ticket,
+          file,
+          file.type || "application/octet-stream",
+          {
+            signal: controller.signal,
+            concurrency: options.concurrency,
+            completedParts,
+            onProgress: (p) => {
+              setProgress(p);
+              options.onProgress?.(p);
+            },
+            onPartDone: (part) => {
+              const all2 = loadResume();
+              const rec = all2[fp];
+              if (rec) {
+                rec.parts = [...rec.parts.filter((x) => x.partNumber !== part.partNumber), part];
+                rec.savedAt = Date.now();
+                saveResume(all2);
+              }
+            }
+          }
+        );
+        const all = loadResume();
+        delete all[fp];
+        saveResume(all);
+        setResult(asset);
+        setStatus("done");
+        return asset;
+      } catch (e) {
+        const err = e instanceof PiFilesError ? e : new PiFilesError(0, "UNKNOWN", e?.message ?? "\u0E2D\u0E31\u0E1B\u0E42\u0E2B\u0E25\u0E14\u0E44\u0E21\u0E48\u0E2A\u0E33\u0E40\u0E23\u0E47\u0E08");
+        if (err.code === "ABORTED") {
+          setStatus("aborted");
+          await api.abort(ticket.uploadId).catch(() => {
+          });
+          const all = loadResume();
+          delete all[fp];
+          saveResume(all);
+        } else {
+          setStatus("error");
+          setError(err);
+        }
+        throw err;
+      }
+    },
+    [api, options.concurrency, options.onProgress]
+  );
+  const cancel = useCallback(() => abortRef.current?.abort(), []);
+  return { upload, cancel, status, progress, error, result };
+}
+function useUploadQueue(options = {}) {
+  const ctx = useContext(Ctx);
+  const endpoint = options.endpoint ?? ctx?.endpoint;
+  if (!endpoint) throw new Error("useUploadQueue \u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 endpoint (prop \u0E2B\u0E23\u0E37\u0E2D <PiFilesProvider>)");
+  const api = useMemo(
+    () => createEndpointApi({
+      endpoint,
+      headers: options.headers ?? ctx?.headers,
+      credentials: options.credentials ?? ctx?.credentials
+    }),
+    [endpoint, options.headers, ctx?.headers, options.credentials, ctx?.credentials]
+  );
+  const [items, setItems] = useState([]);
+  const controllers = useRef(/* @__PURE__ */ new Map());
+  const running = useRef(0);
+  const pending = useRef([]);
+  const parallel = options.parallel ?? 2;
+  const patch = useCallback(
+    (id, p) => setItems((prev) => prev.map((it) => it.id === id ? { ...it, ...p } : it)),
+    []
+  );
+  const pump = useCallback(() => {
+    while (running.current < parallel && pending.current.length) {
+      const next = pending.current.shift();
+      if (!next) break;
+      running.current++;
+      const { item, input } = next;
+      const controller = new AbortController();
+      controllers.current.set(item.id, controller);
+      patch(item.id, { status: "uploading" });
+      (async () => {
+        try {
+          const ticket = await api.create({
+            ...input,
+            filename: item.file.name,
+            mimeType: item.file.type || "application/octet-stream",
+            sizeBytes: item.file.size
+          });
+          const asset = await performUpload(
+            api,
+            ticket,
+            item.file,
+            item.file.type || "application/octet-stream",
+            {
+              signal: controller.signal,
+              concurrency: options.concurrency,
+              onProgress: (progress) => patch(item.id, { progress })
+            }
+          );
+          patch(item.id, {
+            status: "done",
+            result: asset,
+            progress: { loaded: item.file.size, total: item.file.size, fraction: 1 }
+          });
+        } catch (e) {
+          const err = e instanceof PiFilesError ? e : new PiFilesError(0, "UNKNOWN", e?.message ?? "\u0E2D\u0E31\u0E1B\u0E42\u0E2B\u0E25\u0E14\u0E44\u0E21\u0E48\u0E2A\u0E33\u0E40\u0E23\u0E47\u0E08");
+          patch(item.id, { status: err.code === "ABORTED" ? "aborted" : "error", error: err });
+        } finally {
+          controllers.current.delete(item.id);
+          running.current--;
+          pump();
+        }
+      })();
+    }
+  }, [api, parallel, options.concurrency, patch]);
+  const enqueue = useCallback(
+    (files, input = {}) => {
+      const created = files.map((file) => ({
+        id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
+        file,
+        status: "idle",
+        progress: { loaded: 0, total: file.size, fraction: 0 },
+        error: null,
+        result: null
+      }));
+      setItems((prev) => [...prev, ...created]);
+      for (const item of created) pending.current.push({ item, input });
+      pump();
+      return created.map((c) => c.id);
+    },
+    [pump]
+  );
+  const cancel = useCallback((id) => {
+    controllers.current.get(id)?.abort();
+    pending.current = pending.current.filter((p) => p.item.id !== id);
+    setItems(
+      (prev) => prev.map((it) => it.id === id && it.status === "idle" ? { ...it, status: "aborted" } : it)
+    );
+  }, []);
+  const clearFinished = useCallback(
+    () => setItems((prev) => prev.filter((it) => it.status === "uploading" || it.status === "idle")),
+    []
+  );
+  return { items, enqueue, cancel, clearFinished };
+}
+function useReplace(options = {}) {
+  const ctx = useContext(Ctx);
+  const endpoint = options.endpoint ?? ctx?.endpoint;
+  if (!endpoint) throw new Error("useReplace \u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 endpoint (prop \u0E2B\u0E23\u0E37\u0E2D PiFilesProvider)");
+  const api = useMemo(
+    () => createEndpointApi({
+      endpoint,
+      headers: options.headers ?? ctx?.headers,
+      credentials: options.credentials ?? ctx?.credentials
+    }),
+    [endpoint, options.headers, options.credentials, ctx?.headers, ctx?.credentials]
+  );
+  const replaceUrl = options.replaceUrl ?? ((id) => /\/api\/v1\/uploads\/?$/.test(endpoint) ? `${endpoint.replace(/\/uploads\/?$/, "")}/files/${id}/replace` : `${endpoint.replace(/\/$/, "")}/replace/${id}`);
+  const [status, setStatus] = useState("idle");
+  const [progress, setProgress] = useState({ loaded: 0, total: 0, fraction: 0 });
+  const [error, setError] = useState(null);
+  const abortRef = useRef(null);
+  const onProgress = options.onProgress;
+  const replace = useCallback(
+    async (fileId, file) => {
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setStatus("uploading");
+      setError(null);
+      setProgress({ loaded: 0, total: file.size, fraction: 0 });
+      const ticket = await endpointFetch(
+        {
+          endpoint: replaceUrl(fileId),
+          headers: options.headers ?? ctx?.headers,
+          credentials: options.credentials ?? ctx?.credentials
+        },
+        "",
+        {
+          method: "POST",
+          body: JSON.stringify({
+            mimeType: file.type || "application/octet-stream",
+            sizeBytes: file.size
+          })
+        }
+      );
+      try {
+        const asset = await performUpload(
+          api,
+          ticket,
+          file,
+          file.type || "application/octet-stream",
+          {
+            signal: controller.signal,
+            concurrency: options.concurrency,
+            onProgress: (p) => {
+              setProgress(p);
+              onProgress?.(p);
+            }
+          }
+        );
+        setStatus("done");
+        return asset;
+      } catch (e) {
+        const err = e instanceof PiFilesError ? e : new PiFilesError(0, "REPLACE_FAILED", String(e));
+        setError(err);
+        setStatus(controller.signal.aborted ? "aborted" : "error");
+        await api.abort(ticket.uploadId).catch(() => {
+        });
+        throw err;
+      }
+    },
+    [
+      api,
+      replaceUrl,
+      onProgress,
+      options.concurrency,
+      options.headers,
+      options.credentials,
+      ctx?.headers,
+      ctx?.credentials
+    ]
+  );
+  const cancel = useCallback(() => abortRef.current?.abort(), []);
+  return { replace, cancel, status, progress, error };
+}
+export {
+  PiFilesError,
+  PiFilesProvider,
+  createEndpointApi,
+  useReplace,
+  useUpload,
+  useUploadQueue
+};