secure-upload-fastify-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,2069 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ErrorCode: () => ErrorCode,
+  InMemoryFileRepository: () => InMemoryFileRepository,
+  InMemoryMultipartRepository: () => InMemoryMultipartRepository,
+  InMemoryStorage: () => InMemoryStorage,
+  LocalStorage: () => LocalStorage,
+  PrismaFileRepository: () => PrismaFileRepository,
+  PrismaMultipartRepository: () => PrismaMultipartRepository,
+  SecureError: () => SecureError,
+  getHttpStatus: () => getHttpStatus,
+  secureUploadPlugin: () => fastify_plugin_default
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/server/fastify-plugin.ts
+var import_fastify_plugin = __toESM(require("fastify-plugin"));
+
+// src/server/utils/storage/local.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+var import_node_crypto = require("crypto");
+var LocalStorage = class {
+  baseDir;
+  constructor(opts) {
+    this.baseDir = typeof opts === "string" ? opts : opts.baseDir;
+  }
+  // ============================================================
+  // 内部工具
+  // ============================================================
+  inferExt(filename, contentType) {
+    const fromName = import_node_path.default.extname(filename).toLowerCase();
+    if (fromName) return fromName;
+    const map = {
+      "image/png": ".png",
+      "image/jpeg": ".jpg",
+      "image/gif": ".gif",
+      "image/webp": ".webp",
+      "image/svg+xml": ".svg",
+      "application/pdf": ".pdf",
+      "text/plain": ".txt",
+      "application/json": ".json",
+      "application/zip": ".zip",
+      "video/mp4": ".mp4"
+    };
+    return map[contentType] ?? ".bin";
+  }
+  generateKey(filename, contentType, id) {
+    const now = /* @__PURE__ */ new Date();
+    const yyyy = now.getFullYear();
+    const mm = String(now.getMonth() + 1).padStart(2, "0");
+    const dd = String(now.getDate()).padStart(2, "0");
+    const ext = this.inferExt(filename, contentType);
+    return `${yyyy}/${mm}/${dd}/${id}${ext}`;
+  }
+  multipartDir(uploadId) {
+    return import_node_path.default.resolve(this.baseDir, "_multipart", uploadId);
+  }
+  partPath(uploadId, partNumber) {
+    if (!Number.isInteger(partNumber) || partNumber < 1) {
+      throw new Error(`[storage] partNumber \u975E\u6CD5: ${partNumber}`);
+    }
+    return import_node_path.default.join(this.multipartDir(uploadId), `part_${String(partNumber).padStart(4, "0")}.bin`);
+  }
+  // ============================================================
+  // StorageAdapter 实现
+  // ============================================================
+  async put(data, meta) {
+    const key = this.generateKey(meta.filename, meta.contentType, meta.id);
+    const absolutePath = import_node_path.default.resolve(this.baseDir, key);
+    await import_node_fs.promises.mkdir(import_node_path.default.dirname(absolutePath), { recursive: true });
+    await import_node_fs.promises.writeFile(absolutePath, data);
+    return { key, absolutePath };
+  }
+  get(key) {
+    const absolutePath = import_node_path.default.resolve(this.baseDir, key);
+    return (0, import_node_fs.createReadStream)(absolutePath);
+  }
+  async delete(key) {
+    const absolutePath = import_node_path.default.resolve(this.baseDir, key);
+    try {
+      await import_node_fs.promises.unlink(absolutePath);
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+  }
+  async exists(key) {
+    const absolutePath = import_node_path.default.resolve(this.baseDir, key);
+    try {
+      await import_node_fs.promises.access(absolutePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async putPart(uploadId, partNumber, data) {
+    const dir = this.multipartDir(uploadId);
+    await import_node_fs.promises.mkdir(dir, { recursive: true });
+    const finalPath = this.partPath(uploadId, partNumber);
+    const tmpPath = `${finalPath}.tmp`;
+    try {
+      await import_node_fs.promises.writeFile(tmpPath, data);
+      await import_node_fs.promises.rename(tmpPath, finalPath);
+    } catch (e) {
+      try {
+        await import_node_fs.promises.unlink(tmpPath);
+      } catch {
+      }
+      throw e;
+    }
+    return { size: data.length, path: finalPath };
+  }
+  async listParts(uploadId) {
+    const dir = this.multipartDir(uploadId);
+    try {
+      const names = await import_node_fs.promises.readdir(dir);
+      const nums = [];
+      for (const n of names) {
+        const m = n.match(/^part_(\d{4,})\.bin$/);
+        if (m) nums.push(parseInt(m[1], 10));
+      }
+      nums.sort((a, b) => a - b);
+      return nums;
+    } catch (e) {
+      if (e.code === "ENOENT") return [];
+      throw e;
+    }
+  }
+  async partSize(uploadId, partNumber) {
+    const p = this.partPath(uploadId, partNumber);
+    const stat = await import_node_fs.promises.stat(p);
+    return stat.size;
+  }
+  async mergeParts(uploadId, totalParts, target) {
+    const key = this.generateKey(target.filename, target.contentType, target.id);
+    const absolutePath = import_node_path.default.resolve(this.baseDir, key);
+    await import_node_fs.promises.mkdir(import_node_path.default.dirname(absolutePath), { recursive: true });
+    const tmpPath = `${absolutePath}.merge.tmp`;
+    const out = (0, import_node_fs.createWriteStream)(tmpPath);
+    try {
+      for (let i = 1; i <= totalParts; i++) {
+        const partPath = this.partPath(uploadId, i);
+        try {
+          await import_node_fs.promises.access(partPath);
+        } catch {
+          throw new Error(`[storage] \u7F3A\u5206\u7247 part_${i} (uploadId=${uploadId})`);
+        }
+        await new Promise((resolve, reject) => {
+          const rs = (0, import_node_fs.createReadStream)(partPath);
+          rs.on("error", reject);
+          rs.on("end", resolve);
+          rs.pipe(out, { end: false });
+        });
+      }
+      out.end();
+      await new Promise((resolve, reject) => {
+        out.on("finish", () => resolve());
+        out.on("error", reject);
+      });
+      const stat = await import_node_fs.promises.stat(tmpPath);
+      await import_node_fs.promises.rename(tmpPath, absolutePath);
+      return { key, absolutePath, size: stat.size };
+    } catch (e) {
+      try {
+        await import_node_fs.promises.unlink(tmpPath);
+      } catch {
+      }
+      throw e;
+    }
+  }
+  async cleanupMultipart(uploadId) {
+    const dir = this.multipartDir(uploadId);
+    try {
+      await import_node_fs.promises.rm(dir, { recursive: true, force: true });
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        console.warn(`[storage] cleanup multipart failed: uploadId=${uploadId} err=${e.message}`);
+      }
+    }
+  }
+  async computeMergedHash(uploadId, totalParts) {
+    const hash = (0, import_node_crypto.createHash)("sha256");
+    for (let i = 1; i <= totalParts; i++) {
+      const partPath = this.partPath(uploadId, i);
+      const stream = (0, import_node_fs.createReadStream)(partPath);
+      await new Promise((resolve, reject) => {
+        stream.on("data", (chunk) => hash.update(chunk));
+        stream.on("end", resolve);
+        stream.on("error", reject);
+      });
+    }
+    return hash.digest("hex");
+  }
+};
+
+// src/server/utils/storage/memory.ts
+var import_node_stream = require("stream");
+var import_node_crypto2 = require("crypto");
+var InMemoryStorage = class {
+  files = /* @__PURE__ */ new Map();
+  parts = /* @__PURE__ */ new Map();
+  async put(data, meta) {
+    const key = `mem/${meta.id}`;
+    this.files.set(key, Buffer.from(data));
+    return { key };
+  }
+  get(key) {
+    const buf = this.files.get(key);
+    if (!buf) throw new Error(`[memory-storage] not found: ${key}`);
+    return import_node_stream.Readable.from(buf);
+  }
+  async delete(key) {
+    this.files.delete(key);
+  }
+  async exists(key) {
+    return this.files.has(key);
+  }
+  async putPart(uploadId, partNumber, data) {
+    let m = this.parts.get(uploadId);
+    if (!m) {
+      m = /* @__PURE__ */ new Map();
+      this.parts.set(uploadId, m);
+    }
+    m.set(partNumber, Buffer.from(data));
+    return { size: data.length };
+  }
+  async listParts(uploadId) {
+    const m = this.parts.get(uploadId);
+    if (!m) return [];
+    return [...m.keys()].sort((a, b) => a - b);
+  }
+  async mergeParts(uploadId, totalParts, target) {
+    const m = this.parts.get(uploadId);
+    if (!m) throw new Error(`[memory-storage] no parts for ${uploadId}`);
+    const parts = [];
+    for (let i = 1; i <= totalParts; i++) {
+      const p = m.get(i);
+      if (!p) throw new Error(`[memory-storage] missing part ${i}`);
+      parts.push(p);
+    }
+    const merged = Buffer.concat(parts);
+    const key = `mem/${target.id}`;
+    this.files.set(key, merged);
+    return { key, size: merged.length };
+  }
+  async computeMergedHash(uploadId, totalParts) {
+    const hash = (0, import_node_crypto2.createHash)("sha256");
+    const m = this.parts.get(uploadId);
+    if (!m) throw new Error(`[memory-storage] no parts for ${uploadId}`);
+    for (let i = 1; i <= totalParts; i++) {
+      const p = m.get(i);
+      if (!p) throw new Error(`[memory-storage] missing part ${i}`);
+      hash.update(p);
+    }
+    return hash.digest("hex");
+  }
+  async cleanupMultipart(uploadId) {
+    this.parts.delete(uploadId);
+  }
+};
+
+// src/server/utils/repository/types.ts
+var MultipartStatus = {
+  INIT: "INIT",
+  UPLOADING: "UPLOADING",
+  COMPLETED: "COMPLETED",
+  ABORTED: "ABORTED",
+  EXPIRED: "EXPIRED",
+  FAILED: "FAILED"
+};
+var FileStatus = {
+  PENDING: "PENDING",
+  UPLOADING: "UPLOADING",
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED"
+};
+
+// src/server/utils/repository/prisma.ts
+function toMultipartRecord(row) {
+  return {
+    id: row.id,
+    userId: row.userId,
+    filename: row.filename,
+    contentType: row.contentType,
+    totalSize: row.totalSize,
+    partSize: row.partSize,
+    totalParts: row.totalParts,
+    isPublic: row.isPublic,
+    status: row.status,
+    receivedParts: Array.isArray(row.receivedParts) ? row.receivedParts : [],
+    partHashes: row.partHashes && typeof row.partHashes === "object" ? row.partHashes : {},
+    meta: row.meta && typeof row.meta === "object" ? row.meta : null,
+    expectedHash: row.expectedHash,
+    fileId: row.fileId,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    expiresAt: row.expiresAt,
+    completedAt: row.completedAt,
+    abortedAt: row.abortedAt
+  };
+}
+function toFileRecord(row) {
+  return {
+    id: row.id,
+    userId: row.userId,
+    filename: row.filename,
+    contentType: row.contentType,
+    size: row.size,
+    storageKey: row.storageKey,
+    isPublic: row.isPublic,
+    status: row.status,
+    uploadId: row.uploadId,
+    totalParts: row.totalParts,
+    contentHash: row.contentHash,
+    meta: row.meta && typeof row.meta === "object" ? row.meta : null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    deletedAt: row.deletedAt
+  };
+}
+var PrismaMultipartRepository = class {
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  prisma;
+  async createInit(input) {
+    const expiresAt = new Date(Date.now() + input.ttlSeconds * 1e3);
+    const row = await this.prisma.multipartUpload.create({
+      data: {
+        userId: input.userId,
+        filename: input.filename,
+        contentType: input.contentType,
+        totalSize: BigInt(input.totalSize),
+        partSize: input.partSize,
+        totalParts: input.totalParts,
+        isPublic: input.isPublic,
+        status: MultipartStatus.INIT,
+        receivedParts: [],
+        partHashes: {},
+        meta: input.meta ?? void 0,
+        expectedHash: input.expectedHash ?? null,
+        expiresAt
+      }
+    });
+    return toMultipartRecord(row);
+  }
+  async findById(id) {
+    const row = await this.prisma.multipartUpload.findUnique({ where: { id } });
+    return row ? toMultipartRecord(row) : null;
+  }
+  async addPart(id, partNumber, partHash) {
+    return await this.prisma.$transaction(async (tx) => {
+      const row = await tx.multipartUpload.findUnique({ where: { id } });
+      if (!row) throw new Error("NOT_FOUND");
+      const received = Array.isArray(row.receivedParts) ? row.receivedParts : [];
+      const hashes = row.partHashes && typeof row.partHashes === "object" ? row.partHashes : {};
+      if (received.includes(partNumber)) {
+        return {
+          updated: false,
+          duplicate: true,
+          existingHash: hashes[String(partNumber)] ?? null,
+          record: toMultipartRecord(row)
+        };
+      }
+      const next = [...received, partNumber].sort((a, b) => a - b);
+      const nextHashes = { ...hashes };
+      if (partHash) nextHashes[String(partNumber)] = partHash;
+      const newStatus = row.status === MultipartStatus.INIT ? MultipartStatus.UPLOADING : row.status;
+      if (row.status === MultipartStatus.COMPLETED || row.status === MultipartStatus.ABORTED || row.status === MultipartStatus.EXPIRED || row.status === MultipartStatus.FAILED) {
+        throw new Error("STATUS_INVALID");
+      }
+      const updated = await tx.multipartUpload.update({
+        where: { id },
+        data: {
+          receivedParts: next,
+          partHashes: nextHashes,
+          status: newStatus
+        }
+      });
+      return { updated: true, record: toMultipartRecord(updated) };
+    });
+  }
+  async markCompleted(id, fileId) {
+    const row = await this.prisma.multipartUpload.updateMany({
+      where: { id, status: { in: [MultipartStatus.INIT, MultipartStatus.UPLOADING] } },
+      data: {
+        status: MultipartStatus.COMPLETED,
+        fileId,
+        completedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    if (row.count === 0) {
+      const cur = await this.prisma.multipartUpload.findUnique({ where: { id } });
+      if (!cur) throw new Error("NOT_FOUND");
+      throw new Error("STATUS_INVALID");
+    }
+    const fresh = await this.prisma.multipartUpload.findUnique({ where: { id } });
+    return toMultipartRecord(fresh);
+  }
+  async markAborted(id) {
+    const row = await this.prisma.multipartUpload.updateMany({
+      where: { id, status: { in: [MultipartStatus.INIT, MultipartStatus.UPLOADING] } },
+      data: {
+        status: MultipartStatus.ABORTED,
+        abortedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    if (row.count === 0) {
+      const cur = await this.prisma.multipartUpload.findUnique({ where: { id } });
+      if (!cur) throw new Error("NOT_FOUND");
+      if (cur.status === MultipartStatus.COMPLETED) throw new Error("ALREADY_COMPLETED");
+      throw new Error("STATUS_INVALID");
+    }
+    const fresh = await this.prisma.multipartUpload.findUnique({ where: { id } });
+    return toMultipartRecord(fresh);
+  }
+  async markExpired(id) {
+    await this.prisma.multipartUpload.updateMany({
+      where: { id, status: { in: [MultipartStatus.INIT, MultipartStatus.UPLOADING] } },
+      data: {
+        status: MultipartStatus.EXPIRED,
+        abortedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  async listExpired(limit) {
+    const rows = await this.prisma.multipartUpload.findMany({
+      where: {
+        status: { in: [MultipartStatus.INIT, MultipartStatus.UPLOADING] },
+        expiresAt: { lt: /* @__PURE__ */ new Date() }
+      },
+      take: limit,
+      orderBy: { expiresAt: "asc" }
+    });
+    return rows.map(toMultipartRecord);
+  }
+};
+var PrismaFileRepository = class {
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  prisma;
+  async findByHash(hash) {
+    const row = await this.prisma.file.findFirst({
+      where: { contentHash: hash, deletedAt: null }
+    });
+    return row ? toFileRecord(row) : null;
+  }
+  async findDedupCandidate(hash, isPublic, userId) {
+    const row = await this.prisma.file.findFirst({
+      where: {
+        contentHash: hash,
+        deletedAt: null,
+        isPublic,
+        ...isPublic ? {} : { userId }
+      },
+      orderBy: { createdAt: "asc" }
+    });
+    return row ? toFileRecord(row) : null;
+  }
+  async findById(id) {
+    const row = await this.prisma.file.findUnique({ where: { id } });
+    return row ? toFileRecord(row) : null;
+  }
+  async create(input) {
+    const row = await this.prisma.file.create({
+      data: {
+        id: input.id,
+        userId: input.userId,
+        filename: input.filename,
+        contentType: input.contentType,
+        size: BigInt(input.size),
+        storageKey: input.storageKey,
+        isPublic: input.isPublic,
+        status: FileStatus.COMPLETED,
+        uploadId: input.uploadId,
+        totalParts: input.totalParts,
+        contentHash: input.contentHash,
+        meta: input.meta ?? void 0
+      }
+    });
+    return toFileRecord(row);
+  }
+  async softDelete(id, metaPatch) {
+    if (metaPatch) {
+      const cur = await this.prisma.file.findUnique({ where: { id } });
+      const next = { ...cur?.meta ?? {}, ...metaPatch };
+      await this.prisma.file.update({
+        where: { id },
+        data: { deletedAt: /* @__PURE__ */ new Date(), meta: next }
+      });
+    } else {
+      await this.prisma.file.update({
+        where: { id },
+        data: { deletedAt: /* @__PURE__ */ new Date() }
+      });
+    }
+  }
+  async listOrphans(opts) {
+    const lookbackMs = opts.sinceDays * 24 * 3600 * 1e3;
+    const rows = await this.prisma.file.findMany({
+      where: {
+        deletedAt: null,
+        storageKey: { not: "" },
+        createdAt: { gt: new Date(Date.now() - lookbackMs) }
+      },
+      select: {
+        id: true,
+        userId: true,
+        filename: true,
+        contentType: true,
+        size: true,
+        storageKey: true,
+        isPublic: true,
+        status: true,
+        uploadId: true,
+        totalParts: true,
+        contentHash: true,
+        meta: true,
+        createdAt: true,
+        updatedAt: true,
+        deletedAt: true
+      },
+      take: opts.limit,
+      orderBy: { createdAt: "desc" }
+    });
+    return rows.map(toFileRecord);
+  }
+};
+
+// src/server/utils/repository/memory.ts
+var InMemoryMultipartRepository = class {
+  store = /* @__PURE__ */ new Map();
+  idCounter = 0;
+  nextId() {
+    return `mp_${Date.now()}_${++this.idCounter}`;
+  }
+  async createInit(input) {
+    const id = this.nextId();
+    const now = /* @__PURE__ */ new Date();
+    const rec = {
+      id,
+      userId: input.userId,
+      filename: input.filename,
+      contentType: input.contentType,
+      totalSize: BigInt(input.totalSize),
+      partSize: input.partSize,
+      totalParts: input.totalParts,
+      isPublic: input.isPublic,
+      status: MultipartStatus.INIT,
+      receivedParts: [],
+      partHashes: {},
+      meta: input.meta ?? null,
+      expectedHash: input.expectedHash ?? null,
+      fileId: null,
+      createdAt: now,
+      updatedAt: now,
+      expiresAt: new Date(now.getTime() + input.ttlSeconds * 1e3),
+      completedAt: null,
+      abortedAt: null
+    };
+    this.store.set(id, rec);
+    return rec;
+  }
+  async findById(id) {
+    return this.store.get(id) ?? null;
+  }
+  async addPart(id, partNumber, partHash) {
+    const rec = this.store.get(id);
+    if (!rec) throw new Error("NOT_FOUND");
+    if (rec.status === MultipartStatus.COMPLETED || rec.status === MultipartStatus.ABORTED || rec.status === MultipartStatus.EXPIRED || rec.status === MultipartStatus.FAILED) {
+      throw new Error("STATUS_INVALID");
+    }
+    if (rec.receivedParts.includes(partNumber)) {
+      return {
+        updated: false,
+        duplicate: true,
+        existingHash: rec.partHashes[String(partNumber)] ?? null,
+        record: rec
+      };
+    }
+    const next = [...rec.receivedParts, partNumber].sort((a, b) => a - b);
+    const nextHashes = { ...rec.partHashes };
+    if (partHash) nextHashes[String(partNumber)] = partHash;
+    const updated = {
+      ...rec,
+      receivedParts: next,
+      partHashes: nextHashes,
+      status: rec.status === MultipartStatus.INIT ? MultipartStatus.UPLOADING : rec.status,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.store.set(id, updated);
+    return { updated: true, record: updated };
+  }
+  async markCompleted(id, fileId) {
+    const rec = this.store.get(id);
+    if (!rec) throw new Error("NOT_FOUND");
+    if (rec.status !== MultipartStatus.INIT && rec.status !== MultipartStatus.UPLOADING) {
+      throw new Error("STATUS_INVALID");
+    }
+    const updated = {
+      ...rec,
+      status: MultipartStatus.COMPLETED,
+      fileId,
+      completedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.store.set(id, updated);
+    return updated;
+  }
+  async markAborted(id) {
+    const rec = this.store.get(id);
+    if (!rec) throw new Error("NOT_FOUND");
+    if (rec.status === MultipartStatus.COMPLETED) throw new Error("ALREADY_COMPLETED");
+    if (rec.status !== MultipartStatus.INIT && rec.status !== MultipartStatus.UPLOADING) {
+      throw new Error("STATUS_INVALID");
+    }
+    const updated = {
+      ...rec,
+      status: MultipartStatus.ABORTED,
+      abortedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.store.set(id, updated);
+    return updated;
+  }
+  async markExpired(id) {
+    const rec = this.store.get(id);
+    if (!rec) return;
+    if (rec.status !== MultipartStatus.INIT && rec.status !== MultipartStatus.UPLOADING) return;
+    this.store.set(id, {
+      ...rec,
+      status: MultipartStatus.EXPIRED,
+      abortedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+  }
+  async listExpired(limit) {
+    const now = Date.now();
+    const list = [];
+    for (const rec of this.store.values()) {
+      if ((rec.status === MultipartStatus.INIT || rec.status === MultipartStatus.UPLOADING) && rec.expiresAt.getTime() < now) {
+        list.push(rec);
+      }
+    }
+    list.sort((a, b) => a.expiresAt.getTime() - b.expiresAt.getTime());
+    return list.slice(0, limit);
+  }
+};
+var InMemoryFileRepository = class {
+  store = /* @__PURE__ */ new Map();
+  idCounter = 0;
+  nextId() {
+    return `f_${Date.now()}_${++this.idCounter}`;
+  }
+  async findByHash(hash) {
+    for (const f of this.store.values()) {
+      if (f.contentHash === hash && !f.deletedAt) return f;
+    }
+    return null;
+  }
+  async findDedupCandidate(hash, isPublic, userId) {
+    for (const f of this.store.values()) {
+      if (f.deletedAt) continue;
+      if (f.contentHash !== hash) continue;
+      if (f.isPublic !== isPublic) continue;
+      if (!isPublic && f.userId !== userId) continue;
+      return f;
+    }
+    return null;
+  }
+  async findById(id) {
+    return this.store.get(id) ?? null;
+  }
+  async create(input) {
+    let id = input.id;
+    if (!id) id = this.nextId();
+    const now = /* @__PURE__ */ new Date();
+    const rec = {
+      id,
+      userId: input.userId,
+      filename: input.filename,
+      contentType: input.contentType,
+      size: BigInt(input.size),
+      storageKey: input.storageKey,
+      isPublic: input.isPublic,
+      status: FileStatus.COMPLETED,
+      uploadId: input.uploadId,
+      totalParts: input.totalParts,
+      contentHash: input.contentHash,
+      meta: input.meta ?? null,
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null
+    };
+    this.store.set(id, rec);
+    return rec;
+  }
+  async softDelete(id, metaPatch) {
+    const rec = this.store.get(id);
+    if (!rec) return;
+    const next = {
+      ...rec,
+      meta: metaPatch ? { ...rec.meta ?? {}, ...metaPatch } : rec.meta,
+      deletedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.store.set(id, next);
+  }
+  async listOrphans(opts) {
+    const sinceMs = opts.sinceDays * 24 * 3600 * 1e3;
+    const list = [];
+    for (const f of this.store.values()) {
+      if (f.deletedAt) continue;
+      if (f.createdAt.getTime() < Date.now() - sinceMs) continue;
+      list.push(f);
+    }
+    list.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    return list.slice(0, opts.limit);
+  }
+};
+
+// src/server/utils/strategy.ts
+var DEFAULT_STRATEGY_CONFIG = {
+  oneShotMax: 1024 * 1024,
+  // 1MB
+  defaultPartSize: 1024 * 1024,
+  // 1MB
+  bigFileThreshold: 1024 ** 3,
+  // 1GB
+  bigFilePartSize: 5 * 1024 * 1024,
+  // 5MB
+  hugeFileThreshold: 10 * 1024 ** 3,
+  // 10GB
+  hugeFilePartSize: 10 * 1024 * 1024
+  // 10MB
+};
+function chooseStrategy(totalSize, cfg = DEFAULT_STRATEGY_CONFIG) {
+  if (!Number.isFinite(totalSize) || totalSize < 0) {
+    throw new Error(`[strategy] totalSize \u975E\u6CD5: ${totalSize}(\u5FC5\u987B \u2265 0 \u7684\u6709\u9650\u6570)`);
+  }
+  validateConfig(cfg);
+  if (totalSize === 0) {
+    return { kind: "ONE_SHOT", partSize: 0, totalParts: 1, reason: "0\u5B57\u8282" };
+  }
+  if (totalSize <= cfg.oneShotMax) {
+    return {
+      kind: "ONE_SHOT",
+      partSize: totalSize,
+      totalParts: 1,
+      reason: `\u2264 ${cfg.oneShotMax}B \u8D70 ONE_SHOT(1 part \u76F4\u4F20)`
+    };
+  }
+  if (totalSize > cfg.hugeFileThreshold) {
+    const partSize2 = cfg.hugeFilePartSize;
+    return {
+      kind: "MULTIPART",
+      partSize: partSize2,
+      totalParts: Math.ceil(totalSize / partSize2),
+      reason: `> ${cfg.hugeFileThreshold}B \u8D70 HUGE(${partSize2}B/part)`
+    };
+  }
+  if (totalSize > cfg.bigFileThreshold) {
+    const partSize2 = cfg.bigFilePartSize;
+    return {
+      kind: "MULTIPART",
+      partSize: partSize2,
+      totalParts: Math.ceil(totalSize / partSize2),
+      reason: `> ${cfg.bigFileThreshold}B \u8D70 BIG(${partSize2}B/part)`
+    };
+  }
+  const partSize = cfg.defaultPartSize;
+  return {
+    kind: "MULTIPART",
+    partSize,
+    totalParts: Math.ceil(totalSize / partSize),
+    reason: `\u2264 ${cfg.bigFileThreshold}B \u8D70 DEFAULT(${partSize}B/part)`
+  };
+}
+function suggestConcurrency(s) {
+  if (s.kind === "ONE_SHOT") return 1;
+  if (s.totalParts <= 4) return Math.max(1, s.totalParts);
+  return 4;
+}
+function validateConfig(cfg) {
+  const fields = [
+    ["oneShotMax", "oneShotMax"],
+    ["defaultPartSize", "defaultPartSize"],
+    ["bigFileThreshold", "bigFileThreshold"],
+    ["bigFilePartSize", "bigFilePartSize"],
+    ["hugeFileThreshold", "hugeFileThreshold"],
+    ["hugeFilePartSize", "hugeFilePartSize"]
+  ];
+  for (const [k, name] of fields) {
+    if (!Number.isFinite(cfg[k]) || cfg[k] <= 0) {
+      throw new Error(`[strategy] cfg.${name} \u975E\u6CD5: ${cfg[k]}(\u5FC5\u987B > 0)`);
+    }
+  }
+  if (cfg.oneShotMax > cfg.defaultPartSize) {
+    throw new Error(
+      `[strategy] oneShotMax(${cfg.oneShotMax}) \u4E0D\u80FD > defaultPartSize(${cfg.defaultPartSize})`
+    );
+  }
+  if (cfg.bigFileThreshold >= cfg.hugeFileThreshold) {
+    throw new Error(
+      `[strategy] bigFileThreshold(${cfg.bigFileThreshold}) \u5FC5\u987B < hugeFileThreshold(${cfg.hugeFileThreshold})`
+    );
+  }
+  if (cfg.defaultPartSize > cfg.bigFilePartSize) {
+    throw new Error(
+      `[strategy] defaultPartSize(${cfg.defaultPartSize}) \u4E0D\u80FD > bigFilePartSize(${cfg.bigFilePartSize})`
+    );
+  }
+  if (cfg.bigFilePartSize > cfg.hugeFilePartSize) {
+    throw new Error(
+      `[strategy] bigFilePartSize(${cfg.bigFilePartSize}) \u4E0D\u80FD > hugeFilePartSize(${cfg.hugeFilePartSize})`
+    );
+  }
+}
+
+// src/server/errors.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2[ErrorCode2["INVALID_REQUEST"] = 1001] = "INVALID_REQUEST";
+  ErrorCode2[ErrorCode2["INTERNAL_ERROR"] = 1500] = "INTERNAL_ERROR";
+  ErrorCode2[ErrorCode2["NOT_FOUND"] = 1400] = "NOT_FOUND";
+  ErrorCode2[ErrorCode2["FORBIDDEN"] = 1403] = "FORBIDDEN";
+  ErrorCode2[ErrorCode2["RATE_LIMITED"] = 1402] = "RATE_LIMITED";
+  ErrorCode2[ErrorCode2["BINARY_PAYLOAD_EMPTY"] = 1501] = "BINARY_PAYLOAD_EMPTY";
+  ErrorCode2[ErrorCode2["BINARY_PAYLOAD_TOO_LARGE"] = 1502] = "BINARY_PAYLOAD_TOO_LARGE";
+  ErrorCode2[ErrorCode2["BINARY_AUTH_REQUIRED"] = 1503] = "BINARY_AUTH_REQUIRED";
+  ErrorCode2[ErrorCode2["BINARY_AUTH_FAILED"] = 1504] = "BINARY_AUTH_FAILED";
+  ErrorCode2[ErrorCode2["BATCH_EMPTY"] = 1510] = "BATCH_EMPTY";
+  ErrorCode2[ErrorCode2["BATCH_TOO_MANY_FILES"] = 1511] = "BATCH_TOO_MANY_FILES";
+  ErrorCode2[ErrorCode2["BATCH_TOTAL_TOO_LARGE"] = 1512] = "BATCH_TOTAL_TOO_LARGE";
+  ErrorCode2[ErrorCode2["BATCH_FILE_INVALID"] = 1513] = "BATCH_FILE_INVALID";
+  ErrorCode2[ErrorCode2["MULTIPART_NOT_FOUND"] = 1520] = "MULTIPART_NOT_FOUND";
+  ErrorCode2[ErrorCode2["MULTIPART_ALREADY_COMPLETED"] = 1521] = "MULTIPART_ALREADY_COMPLETED";
+  ErrorCode2[ErrorCode2["MULTIPART_ALREADY_ABORTED"] = 1522] = "MULTIPART_ALREADY_ABORTED";
+  ErrorCode2[ErrorCode2["MULTIPART_EXPIRED"] = 1523] = "MULTIPART_EXPIRED";
+  ErrorCode2[ErrorCode2["MULTIPART_STATUS_INVALID"] = 1524] = "MULTIPART_STATUS_INVALID";
+  ErrorCode2[ErrorCode2["MULTIPART_TOTAL_TOO_LARGE"] = 1530] = "MULTIPART_TOTAL_TOO_LARGE";
+  ErrorCode2[ErrorCode2["MULTIPART_PART_TOO_LARGE"] = 1531] = "MULTIPART_PART_TOO_LARGE";
+  ErrorCode2[ErrorCode2["MULTIPART_PART_TOO_SMALL"] = 1532] = "MULTIPART_PART_TOO_SMALL";
+  ErrorCode2[ErrorCode2["MULTIPART_INVALID_PART_NUMBER"] = 1533] = "MULTIPART_INVALID_PART_NUMBER";
+  ErrorCode2[ErrorCode2["MULTIPART_DUPLICATE_PART"] = 1534] = "MULTIPART_DUPLICATE_PART";
+  ErrorCode2[ErrorCode2["MULTIPART_PART_HASH_MISMATCH"] = 1535] = "MULTIPART_PART_HASH_MISMATCH";
+  ErrorCode2[ErrorCode2["MULTIPART_FINAL_HASH_MISMATCH"] = 1536] = "MULTIPART_FINAL_HASH_MISMATCH";
+  ErrorCode2[ErrorCode2["MULTIPART_INCOMPLETE_PARTS"] = 1537] = "MULTIPART_INCOMPLETE_PARTS";
+  ErrorCode2[ErrorCode2["MULTIPART_AUTH_REQUIRED"] = 1538] = "MULTIPART_AUTH_REQUIRED";
+  ErrorCode2[ErrorCode2["MULTIPART_INVALID_ARG"] = 1539] = "MULTIPART_INVALID_ARG";
+  return ErrorCode2;
+})(ErrorCode || {});
+var HTTP = {
+  [1001 /* INVALID_REQUEST */]: 400,
+  [1500 /* INTERNAL_ERROR */]: 500,
+  [1400 /* NOT_FOUND */]: 404,
+  [1403 /* FORBIDDEN */]: 403,
+  [1402 /* RATE_LIMITED */]: 429,
+  // binary
+  [1501 /* BINARY_PAYLOAD_EMPTY */]: 400,
+  [1502 /* BINARY_PAYLOAD_TOO_LARGE */]: 413,
+  [1503 /* BINARY_AUTH_REQUIRED */]: 401,
+  [1504 /* BINARY_AUTH_FAILED */]: 401,
+  // batch
+  [1510 /* BATCH_EMPTY */]: 400,
+  [1511 /* BATCH_TOO_MANY_FILES */]: 413,
+  [1512 /* BATCH_TOTAL_TOO_LARGE */]: 413,
+  [1513 /* BATCH_FILE_INVALID */]: 400,
+  // multipart
+  [1520 /* MULTIPART_NOT_FOUND */]: 404,
+  [1521 /* MULTIPART_ALREADY_COMPLETED */]: 409,
+  [1522 /* MULTIPART_ALREADY_ABORTED */]: 409,
+  [1523 /* MULTIPART_EXPIRED */]: 410,
+  [1524 /* MULTIPART_STATUS_INVALID */]: 409,
+  [1530 /* MULTIPART_TOTAL_TOO_LARGE */]: 413,
+  [1531 /* MULTIPART_PART_TOO_LARGE */]: 413,
+  [1532 /* MULTIPART_PART_TOO_SMALL */]: 400,
+  [1533 /* MULTIPART_INVALID_PART_NUMBER */]: 400,
+  [1534 /* MULTIPART_DUPLICATE_PART */]: 409,
+  [1535 /* MULTIPART_PART_HASH_MISMATCH */]: 400,
+  [1536 /* MULTIPART_FINAL_HASH_MISMATCH */]: 400,
+  [1537 /* MULTIPART_INCOMPLETE_PARTS */]: 409,
+  [1538 /* MULTIPART_AUTH_REQUIRED */]: 401,
+  [1539 /* MULTIPART_INVALID_ARG */]: 400
+};
+var SecureError = class extends Error {
+  constructor(code, message) {
+    super(message ?? ErrorCode[code]);
+    this.code = code;
+    this.name = "SecureError";
+  }
+  code;
+  get statusCode() {
+    return HTTP[this.code];
+  }
+};
+function getHttpStatus(code) {
+  return HTTP[code];
+}
+
+// src/server/session.ts
+function parseJwtPayload(token) {
+  if (!token) return null;
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    return JSON.parse(Buffer.from(parts[1], "base64url").toString("utf-8"));
+  } catch {
+    return null;
+  }
+}
+var defaultSessionValidator = (token, isPublic) => {
+  if (isPublic) return null;
+  if (!token) {
+    throw new SecureError(1503 /* BINARY_AUTH_REQUIRED */, "private \u4E0A\u4F20\u5FC5\u987B\u63D0\u4F9B session (JWT)");
+  }
+  const p = parseJwtPayload(token);
+  if (!p?.sub) throw new SecureError(1504 /* BINARY_AUTH_FAILED */, "session \u683C\u5F0F\u65E0\u6548");
+  if (p.exp && p.exp * 1e3 < Date.now()) {
+    throw new SecureError(1504 /* BINARY_AUTH_FAILED */, "session \u5DF2\u8FC7\u671F");
+  }
+  return Number(p.sub);
+};
+
+// src/server/routes/multipart.ts
+var import_node_crypto3 = __toESM(require("crypto"));
+var import_zod = require("zod");
+
+// src/server/routes/_internal.ts
+async function resolveSession(req, isPublic, validate) {
+  const sr = req.secureRequest;
+  const session = sr?.session ?? req.headers["x-secure-session"];
+  const userId = await validate(session, isPublic);
+  const sessionKey = session ?? "anonymous";
+  return { userId: userId ?? null, sessionKey };
+}
+function resolveSessionKey(req) {
+  const sr = req.secureRequest;
+  return sr?.session ?? req.headers["x-secure-session"] ?? "anonymous";
+}
+async function resolveUserId(req, isPublic, validate) {
+  const sr = req.secureRequest;
+  const session = sr?.session ?? req.headers["x-secure-session"];
+  return await validate(session, isPublic);
+}
+function resolvePartData(req) {
+  const sr = req.secureRequest;
+  if (sr?.raw?.data) {
+    return { data: sr.raw.data, declaredSize: Number(sr.raw.size ?? sr.raw.data.length) };
+  }
+  const rawBase64 = req.headers["x-secure-raw-base64"];
+  const declaredSize = Number(req.headers["x-secure-content-length"] || 0);
+  if (!rawBase64) {
+    throw new SecureError(
+      1001 /* INVALID_REQUEST */,
+      "\u7F3A\u5C11 part \u6570\u636E(secure-crypto \u6A21\u5F0F\u8BFB secureRequest.raw,raw \u6A21\u5F0F\u8BFB x-secure-raw-base64 header)"
+    );
+  }
+  return { data: Buffer.from(rawBase64, "base64"), declaredSize };
+}
+function resolvePartBiz(req) {
+  const sr = req.secureRequest;
+  const biz = sr?.biz ?? req.body ?? {};
+  const uploadId = String(biz.uploadId ?? "").trim();
+  const partNumberRaw = biz.partNumber;
+  const partHash = biz.partHash ?? null;
+  if (!uploadId) {
+    throw new SecureError(1001 /* INVALID_REQUEST */, "\u7F3A\u5C11 uploadId");
+  }
+  const partNumber = Number(partNumberRaw);
+  if (!Number.isInteger(partNumber) || partNumber < 1) {
+    throw new SecureError(1533 /* MULTIPART_INVALID_PART_NUMBER */, `partNumber \u975E\u6CD5: ${partNumberRaw}`);
+  }
+  return { uploadId, partNumber, partHash };
+}
+
+// src/server/utils/redis-helpers.ts
+var LUA_SLIDING_WINDOW_RATE_LIMIT = `
+-- KEYS[1] = rate limit key
+-- ARGV[1] = window (ms)
+-- ARGV[2] = limit (max requests in window)
+-- ARGV[3] = now (ms)
+-- ARGV[4] = member (unique per request)
+local key = KEYS[1]
+local window = tonumber(ARGV[1])
+local limit = tonumber(ARGV[2])
+local now = tonumber(ARGV[3])
+local member = ARGV[4]
+redis.call('ZREMRANGEBYSCORE', key, 0, now - window)
+local count = redis.call('ZCARD', key)
+if count >= limit then
+  local oldest = redis.call('ZRANGE', key, 0, 0, 'WITHSCORES')
+  local retryAfter = window
+  if #oldest >= 2 then
+    retryAfter = (tonumber(oldest[2]) + window) - now
+    if retryAfter < 0 then retryAfter = 0 end
+  end
+  return { 0, retryAfter }
+end
+redis.call('ZADD', key, now, member)
+redis.call('PEXPIRE', key, window)
+return { 1, 0 }
+`;
+var LUA_RELEASE_LOCK = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  return redis.call('DEL', KEYS[1])
+else
+  return 0
+end
+`;
+var LUA_ACQUIRE_LOCK = `
+if redis.call('SET', KEYS[1], ARGV[1], 'NX', 'PX', tonumber(ARGV[2])) then
+  return 1
+else
+  return 0
+end
+`;
+async function slidingWindowRateLimit(redis, key, windowMs, limit) {
+  const now = Date.now();
+  const member = `${now}-${Math.random().toString(36).slice(2, 10)}`;
+  const result = await redis.eval(
+    LUA_SLIDING_WINDOW_RATE_LIMIT,
+    1,
+    key,
+    String(windowMs),
+    String(limit),
+    String(now),
+    member
+  );
+  const ok = result[0] === 1;
+  return {
+    ok,
+    retryAfterMs: ok ? 0 : Number(result[1] ?? 0),
+    remaining: ok ? limit - 1 : 0
+  };
+}
+async function acquireLock(redis, key, ttlMs = 5e3) {
+  const token = `${Date.now()}-${Math.random().toString(36).slice(2, 12)}`;
+  const ok = await redis.eval(LUA_ACQUIRE_LOCK, 1, key, token, String(ttlMs));
+  if (ok === 1) return { ok: true, token };
+  return { ok: false, token: null };
+}
+async function releaseLock(redis, key, token) {
+  const r = await redis.eval(LUA_RELEASE_LOCK, 1, key, token);
+  return r === 1;
+}
+async function withLock(redis, key, ttlMs, fn, retries = 0) {
+  let lastErr;
+  for (let i = 0; i <= retries; i++) {
+    const lock2 = await acquireLock(redis, key, ttlMs);
+    if (lock2.ok) {
+      try {
+        return await fn();
+      } finally {
+        await releaseLock(redis, key, lock2.token).catch(() => {
+        });
+      }
+    }
+    lastErr = new Error(`[redis-helpers] acquireLock failed: ${key}`);
+    if (i < retries) {
+      const wait = 50 * Math.pow(2, i) + Math.floor(Math.random() * 20);
+      await new Promise((r) => setTimeout(r, wait));
+    }
+  }
+  const e = lastErr instanceof Error ? lastErr : new Error("[redis-helpers] withLock failed");
+  e.code = "LOCK_BUSY";
+  throw e;
+}
+
+// src/server/utils/memory-rate-limit.ts
+var _limitStore = /* @__PURE__ */ new Map();
+var _lockStore = /* @__PURE__ */ new Map();
+function gcLimit(now, windowMs) {
+  if (_limitStore.size > 5e3) {
+    for (const [k, v] of _limitStore.entries()) {
+      const filtered = v.timestamps.filter((t) => t > now - windowMs);
+      if (filtered.length === 0) _limitStore.delete(k);
+      else _limitStore.set(k, { timestamps: filtered });
+    }
+  }
+}
+function memorySlidingWindowRateLimit(key, windowMs, limit) {
+  const now = Date.now();
+  gcLimit(now, windowMs);
+  const entry = _limitStore.get(key) ?? { timestamps: [] };
+  entry.timestamps = entry.timestamps.filter((t) => t > now - windowMs);
+  if (entry.timestamps.length >= limit) {
+    const oldest = entry.timestamps[0];
+    const retryAfter = Math.max(0, oldest + windowMs - now);
+    return { ok: false, retryAfterMs: retryAfter, remaining: 0 };
+  }
+  entry.timestamps.push(now);
+  _limitStore.set(key, entry);
+  return { ok: true, retryAfterMs: 0, remaining: limit - entry.timestamps.length };
+}
+function memoryAcquireLock(key) {
+  if (_lockStore.get(key)) return false;
+  _lockStore.set(key, true);
+  return true;
+}
+function memoryReleaseLock(key) {
+  _lockStore.delete(key);
+}
+async function memoryWithLock(key, fn, retries = 0) {
+  for (let i = 0; i <= retries; i++) {
+    if (memoryAcquireLock(key)) {
+      try {
+        return await fn();
+      } finally {
+        memoryReleaseLock(key);
+      }
+    }
+    if (i < retries) {
+      const wait = 50 * Math.pow(2, i) + Math.floor(Math.random() * 20);
+      await new Promise((r) => setTimeout(r, wait));
+    }
+  }
+  const e = new Error(`[memory-lock] LOCK_BUSY: ${key}`);
+  e.code = "LOCK_BUSY";
+  throw e;
+}
+
+// src/server/routes/multipart.ts
+var InitBodySchema = import_zod.z.object({
+  filename: import_zod.z.string().min(1).max(255),
+  contentType: import_zod.z.string().min(1).max(128).default("application/octet-stream"),
+  totalSize: import_zod.z.coerce.number().int().nonnegative(),
+  partSize: import_zod.z.coerce.number().int().positive().optional(),
+  isPublic: import_zod.z.coerce.boolean().default(false),
+  expectedHash: import_zod.z.string().regex(/^[a-f0-9]{64}$/i).optional(),
+  meta: import_zod.z.record(import_zod.z.unknown()).optional()
+}).strict();
+var CompleteBodySchema = import_zod.z.object({
+  uploadId: import_zod.z.string().min(1).max(128),
+  parts: import_zod.z.array(import_zod.z.object({
+    partNumber: import_zod.z.coerce.number().int().positive(),
+    hash: import_zod.z.string().regex(/^[a-f0-9]{64}$/i).optional()
+  })).optional(),
+  finalHash: import_zod.z.string().regex(/^[a-f0-9]{64}$/i).optional()
+}).strict();
+var AbortBodySchema = import_zod.z.object({
+  uploadId: import_zod.z.string().min(1).max(128)
+}).strict();
+var StatusBodySchema = import_zod.z.object({
+  uploadId: import_zod.z.string().min(1).max(128)
+});
+async function rateLimit(rt, key, windowMs, limit) {
+  if (rt.redis) {
+    const r2 = await slidingWindowRateLimit(rt.redis, key, windowMs, limit);
+    return { ok: r2.ok, retryAfterMs: r2.retryAfterMs };
+  }
+  const r = memorySlidingWindowRateLimit(key, windowMs, limit);
+  return { ok: r.ok, retryAfterMs: r.retryAfterMs };
+}
+async function lock(rt, key, ttlMs, fn, retries = 0) {
+  if (rt.redis) {
+    return await withLock(rt.redis, key, ttlMs, fn, retries);
+  }
+  return await memoryWithLock(key, fn, retries);
+}
+async function registerMultipartRoutes(app, rt) {
+  if (!rt.config.enabled) {
+    app.log.warn("\u26A0\uFE0F  multipart \u4E0A\u4F20\u5DF2\u7981\u7528 (enabled=false)");
+    return;
+  }
+  const base = rt.config.multipartPath;
+  app.log.info(
+    {
+      routes: [`${base}/init`, `${base}/part`, `${base}/complete`, `${base}/abort`, `${base}/status`],
+      partMin: rt.config.partMin,
+      partMax: rt.config.partMax,
+      partDefault: rt.config.partDefault,
+      fileMax: rt.config.fileMaxSize,
+      ttl: rt.config.ttlSeconds
+    },
+    "\u{1F527} multipart-routes: \u6CE8\u518C\u5206\u7247\u8DEF\u7531..."
+  );
+  app.post(`${base}/init`, async (req, reply) => {
+    const body = InitBodySchema.parse(req.body ?? {});
+    const { userId, sessionKey } = await resolveSession(req, body.isPublic, rt.validateSession);
+    const rlKey = `rl:mp:init:${userId ?? sessionKey.slice(0, 32)}`;
+    const rl = await rateLimit(rt, rlKey, 6e4, rt.config.initRateLimit);
+    if (!rl.ok) {
+      throw new SecureError(
+        1402 /* RATE_LIMITED */,
+        `init \u8FC7\u4E8E\u9891\u7E41,\u8BF7 ${Math.ceil(rl.retryAfterMs / 1e3)}s \u540E\u91CD\u8BD5`
+      );
+    }
+    if (body.totalSize > rt.config.fileMaxSize) {
+      throw new SecureError(
+        1530 /* MULTIPART_TOTAL_TOO_LARGE */,
+        `\u6587\u4EF6\u603B\u5927\u5C0F ${body.totalSize} \u8D85\u8FC7\u5355\u6587\u4EF6\u9650\u5236 ${rt.config.fileMaxSize}`
+      );
+    }
+    let partSize = body.partSize ?? rt.config.partDefault;
+    if (partSize < rt.config.partMin) partSize = rt.config.partMin;
+    if (partSize > rt.config.partMax) partSize = rt.config.partMax;
+    const totalParts = body.totalSize === 0 ? 1 : Math.ceil(body.totalSize / partSize);
+    if (body.expectedHash) {
+      const existing = await rt.fileRepo.findDedupCandidate(
+        body.expectedHash,
+        body.isPublic,
+        userId
+      );
+      if (existing) {
+        const diskOk = await rt.storage.exists(existing.storageKey).catch(() => false);
+        if (diskOk) {
+          req.log.info(
+            { hash: body.expectedHash, fileId: existing.id, isPublic: body.isPublic, userId },
+            "\u26A1 \u79D2\u4F20\u547D\u4E2D(\u4E25\u683C\u5339\u914D\u53EF\u89C1\u6027+\u8EAB\u4EFD)"
+          );
+          return {
+            success: true,
+            data: {
+              uploadId: "",
+              partSize: 0,
+              totalParts: 0,
+              totalSize: Number(existing.size),
+              expiresAt: "",
+              ttl: 0,
+              suggestedConcurrency: 0,
+              dedup: {
+                fileId: existing.id,
+                filename: existing.filename,
+                size: Number(existing.size),
+                contentType: existing.contentType,
+                url: `${rt.config.fileUrlPrefix}/${existing.id}`
+              }
+            }
+          };
+        }
+        req.log.warn(
+          { hash: body.expectedHash, fileId: existing.id, storageKey: existing.storageKey, userId },
+          "\u26A0\uFE0F DB \u547D\u4E2D\u4F46\u78C1\u76D8\u5DF2\u4E22\u5931,\u653E\u5F03\u79D2\u4F20\u8D70\u6B63\u5E38\u5206\u7247"
+        );
+        await rt.fileRepo.softDelete(existing.id, { orphanedAt: (/* @__PURE__ */ new Date()).toISOString() }).catch((e) => {
+          req.log.warn({ err: e, fileId: existing.id }, "\u26A0\uFE0F \u8F6F\u5220\u9664\u5B64\u513F record \u5931\u8D25");
+        });
+      }
+    }
+    const rec = await rt.multipartRepo.createInit({
+      userId,
+      filename: body.filename,
+      contentType: body.contentType,
+      totalSize: body.totalSize,
+      partSize,
+      totalParts,
+      isPublic: body.isPublic,
+      expectedHash: body.expectedHash ?? null,
+      meta: body.meta ?? null,
+      ttlSeconds: rt.config.ttlSeconds
+    });
+    req.log.info(
+      { uploadId: rec.id, userId, totalSize: body.totalSize, partSize, totalParts, isPublic: body.isPublic },
+      "\u2705 multipart: init"
+    );
+    return {
+      success: true,
+      data: {
+        uploadId: rec.id,
+        partSize,
+        totalParts,
+        totalSize: body.totalSize,
+        expiresAt: rec.expiresAt.toISOString(),
+        ttl: rt.config.ttlSeconds,
+        suggestedConcurrency: rt.config.suggestedConcurrency
+      }
+    };
+  });
+  app.post(`${base}/part`, async (req, reply) => {
+    const { data } = resolvePartData(req);
+    if (data.length === 0) {
+      throw new SecureError(1501 /* BINARY_PAYLOAD_EMPTY */, "part \u6570\u636E\u4E3A\u7A7A");
+    }
+    if (data.length > rt.config.partMax) {
+      throw new SecureError(
+        1531 /* MULTIPART_PART_TOO_LARGE */,
+        `part \u5927\u5C0F ${data.length} \u8D85\u8FC7 ${rt.config.partMax}`
+      );
+    }
+    const { uploadId, partNumber, partHash } = resolvePartBiz(req);
+    const sessionKey = resolveSessionKey(req);
+    const rlKey = `rl:mp:part:${sessionKey.slice(0, 64)}`;
+    const rl = await rateLimit(rt, rlKey, 6e4, rt.config.partRateLimit);
+    if (!rl.ok) {
+      throw new SecureError(
+        1402 /* RATE_LIMITED */,
+        `part \u4E0A\u4F20\u8FC7\u4E8E\u9891\u7E41,\u8BF7 ${Math.ceil(rl.retryAfterMs / 1e3)}s \u540E\u91CD\u8BD5`
+      );
+    }
+    const rec = await rt.multipartRepo.findById(uploadId);
+    if (!rec) {
+      throw new SecureError(1520 /* MULTIPART_NOT_FOUND */, `uploadId \u4E0D\u5B58\u5728: ${uploadId}`);
+    }
+    if (!rec.isPublic) {
+      const userId = await resolveUserIdForRecord(req, rec.userId, rec.isPublic, rt);
+      if (userId === null) {
+        throw new SecureError(1400 /* NOT_FOUND */, "uploadId \u4E0D\u5B58\u5728");
+      }
+    }
+    if (rec.status === MultipartStatus.COMPLETED) {
+      throw new SecureError(1521 /* MULTIPART_ALREADY_COMPLETED */, "uploadId \u5DF2\u5B8C\u6210,\u4E0D\u80FD\u7EE7\u7EED part");
+    }
+    if (rec.status === MultipartStatus.ABORTED) {
+      throw new SecureError(1522 /* MULTIPART_ALREADY_ABORTED */, "uploadId \u5DF2\u7EC8\u6B62,\u4E0D\u80FD\u7EE7\u7EED part");
+    }
+    if (rec.status === MultipartStatus.EXPIRED || rec.expiresAt.getTime() < Date.now()) {
+      throw new SecureError(1523 /* MULTIPART_EXPIRED */, "uploadId \u5DF2\u8FC7\u671F");
+    }
+    if (partNumber < 1 || partNumber > rec.totalParts) {
+      throw new SecureError(
+        1533 /* MULTIPART_INVALID_PART_NUMBER */,
+        `partNumber=${partNumber} \u8D8A\u754C [1, ${rec.totalParts}]`
+      );
+    }
+    const actualHash = import_node_crypto3.default.createHash("sha256").update(data).digest("hex");
+    if (partHash && partHash.toLowerCase() !== actualHash) {
+      throw new SecureError(
+        1535 /* MULTIPART_PART_HASH_MISMATCH */,
+        `part ${partNumber} \u58F0\u660E hash ${partHash} \u4E0E\u5B9E\u9645 ${actualHash} \u4E0D\u4E00\u81F4`
+      );
+    }
+    await rt.storage.putPart(uploadId, partNumber, data);
+    const writeRes = await lock(
+      rt,
+      `lock:mp:${uploadId}:meta`,
+      1e4,
+      async () => {
+        const cur = await rt.multipartRepo.findById(uploadId);
+        if (!cur) throw new SecureError(1520 /* MULTIPART_NOT_FOUND */, "uploadId \u4E0D\u5B58\u5728");
+        if (cur.status === MultipartStatus.COMPLETED) {
+          throw new SecureError(1521 /* MULTIPART_ALREADY_COMPLETED */, "uploadId \u5DF2\u5B8C\u6210");
+        }
+        if (cur.status === MultipartStatus.ABORTED) {
+          throw new SecureError(1522 /* MULTIPART_ALREADY_ABORTED */, "uploadId \u5DF2\u7EC8\u6B62");
+        }
+        const r = await rt.multipartRepo.addPart(uploadId, partNumber, actualHash);
+        if (r.updated) return { ok: true, record: r.record };
+        if (r.existingHash && r.existingHash === actualHash) {
+          return { ok: true, record: r.record, idempotent: true };
+        }
+        throw new SecureError(
+          1534 /* MULTIPART_DUPLICATE_PART */,
+          `part ${partNumber} \u5DF2\u5B58\u5728(\u539F hash=${r.existingHash ?? "null"},\u65B0 hash=${actualHash})`
+        );
+      },
+      5
+    );
+    req.log.info(
+      {
+        uploadId,
+        partNumber,
+        size: data.length,
+        receivedCount: writeRes.record.receivedParts.length,
+        idempotent: writeRes.idempotent === true
+      },
+      "\u2705 multipart: part \u5199\u5165"
+    );
+    return {
+      success: true,
+      data: {
+        uploadId,
+        partNumber,
+        size: data.length,
+        receivedCount: writeRes.record.receivedParts.length,
+        totalParts: rec.totalParts
+      }
+    };
+  });
+  app.post(`${base}/complete`, async (req, reply) => {
+    const body = CompleteBodySchema.parse(req.body ?? {});
+    const rec = await rt.multipartRepo.findById(body.uploadId);
+    if (!rec) {
+      throw new SecureError(1520 /* MULTIPART_NOT_FOUND */, `uploadId \u4E0D\u5B58\u5728`);
+    }
+    if (!rec.isPublic) {
+      await resolveUserIdForRecord(req, rec.userId, rec.isPublic, rt);
+    }
+    if (rec.status === MultipartStatus.COMPLETED) {
+      if (rec.fileId) {
+        const file2 = await rt.fileRepo.findById(rec.fileId);
+        if (file2) {
+          return {
+            success: true,
+            data: {
+              fileId: file2.id,
+              filename: file2.filename,
+              size: Number(file2.size),
+              contentType: file2.contentType,
+              url: `${rt.config.fileUrlPrefix}/${file2.id}`,
+              finalHash: file2.contentHash ?? "",
+              idempotent: true
+            }
+          };
+        }
+      }
+    }
+    if (rec.status === MultipartStatus.ABORTED) {
+      throw new SecureError(1522 /* MULTIPART_ALREADY_ABORTED */, "uploadId \u5DF2\u7EC8\u6B62");
+    }
+    if (rec.status === MultipartStatus.EXPIRED || rec.expiresAt.getTime() < Date.now()) {
+      throw new SecureError(1523 /* MULTIPART_EXPIRED */, "uploadId \u5DF2\u8FC7\u671F");
+    }
+    const expected = Array.from({ length: rec.totalParts }, (_, i) => i + 1);
+    const missing = expected.filter((n) => !rec.receivedParts.includes(n));
+    if (missing.length > 0) {
+      throw new SecureError(
+        1537 /* MULTIPART_INCOMPLETE_PARTS */,
+        `\u7F3A\u5206\u7247: [${missing.slice(0, 10).join(",")}${missing.length > 10 ? `...(${missing.length}\u7247)` : ""}]`
+      );
+    }
+    if (body.parts && body.parts.length > 0) {
+      const expectedHashes = {};
+      for (const p of body.parts) {
+        if (p.hash) expectedHashes[p.partNumber] = p.hash.toLowerCase();
+      }
+      for (const [pnStr, h] of Object.entries(rec.partHashes)) {
+        const pn = Number(pnStr);
+        if (expectedHashes[pn] && expectedHashes[pn] !== h.toLowerCase()) {
+          throw new SecureError(
+            1535 /* MULTIPART_PART_HASH_MISMATCH */,
+            `part ${pn} \u670D\u52A1\u7AEF hash ${h} \u4E0E\u5BA2\u6237\u7AEF\u58F0\u660E ${expectedHashes[pn]} \u4E0D\u4E00\u81F4`
+          );
+        }
+      }
+    }
+    const fileId = `f_${Date.now()}_${import_node_crypto3.default.randomBytes(4).toString("hex")}`;
+    const result = await lock(
+      rt,
+      `lock:mp:${body.uploadId}`,
+      6e4,
+      async () => {
+        const cur = await rt.multipartRepo.findById(body.uploadId);
+        if (!cur) throw new SecureError(1520 /* MULTIPART_NOT_FOUND */, "uploadId \u4E0D\u5B58\u5728");
+        if (cur.status === MultipartStatus.COMPLETED && cur.fileId) {
+          return { idempotent: true, fileId: cur.fileId };
+        }
+        if (cur.status === MultipartStatus.ABORTED) {
+          throw new SecureError(1522 /* MULTIPART_ALREADY_ABORTED */, "uploadId \u5DF2\u7EC8\u6B62");
+        }
+        const merged = await rt.storage.mergeParts(
+          body.uploadId,
+          rec.totalParts,
+          { id: fileId, filename: rec.filename, contentType: rec.contentType }
+        );
+        const finalHash = await rt.storage.computeMergedHash(body.uploadId, rec.totalParts);
+        if (body.finalHash && body.finalHash.toLowerCase() !== finalHash) {
+          await rt.storage.delete(merged.key);
+          throw new SecureError(
+            1536 /* MULTIPART_FINAL_HASH_MISMATCH */,
+            `\u6700\u7EC8 hash \u4E0D\u4E00\u81F4(\u58F0\u660E=${body.finalHash},\u5B9E\u9645=${finalHash})`
+          );
+        }
+        const file2 = await rt.fileRepo.create({
+          id: fileId,
+          userId: rec.userId,
+          filename: rec.filename,
+          contentType: rec.contentType,
+          size: merged.size,
+          storageKey: merged.key,
+          isPublic: rec.isPublic,
+          uploadId: rec.id,
+          totalParts: rec.totalParts,
+          contentHash: finalHash,
+          meta: rec.meta ?? void 0
+        });
+        await rt.multipartRepo.markCompleted(rec.id, fileId);
+        return { idempotent: false, fileId: file2.id, size: merged.size, finalHash };
+      }
+    );
+    if (!result.idempotent) {
+      rt.storage.cleanupMultipart(body.uploadId).catch((e) => {
+        req.log.warn({ err: e, uploadId: body.uploadId }, "\u26A0\uFE0F \u6E05\u7406\u5206\u7247\u76EE\u5F55\u5931\u8D25");
+      });
+    }
+    req.log.info(
+      {
+        uploadId: body.uploadId,
+        fileId: result.fileId,
+        size: result.size,
+        userId: rec.userId
+      },
+      "\u2705 multipart: complete"
+    );
+    const file = await rt.fileRepo.findById(result.fileId);
+    if (!file) {
+      throw new SecureError(1500 /* INTERNAL_ERROR */, "file record lost");
+    }
+    return {
+      success: true,
+      data: {
+        fileId: file.id,
+        filename: file.filename,
+        size: Number(file.size),
+        contentType: file.contentType,
+        url: `${rt.config.fileUrlPrefix}/${file.id}`,
+        finalHash: result.finalHash,
+        idempotent: result.idempotent === true
+      }
+    };
+  });
+  app.post(`${base}/abort`, async (req, reply) => {
+    const body = AbortBodySchema.parse(req.body ?? {});
+    const rec = await rt.multipartRepo.findById(body.uploadId);
+    if (!rec) {
+      throw new SecureError(1520 /* MULTIPART_NOT_FOUND */, `uploadId \u4E0D\u5B58\u5728`);
+    }
+    if (!rec.isPublic) {
+      await resolveUserIdForRecord(req, rec.userId, rec.isPublic, rt);
+    }
+    if (rec.status === MultipartStatus.COMPLETED) {
+      throw new SecureError(1521 /* MULTIPART_ALREADY_COMPLETED */, "\u5DF2\u5B8C\u6210\u7684 uploadId \u4E0D\u80FD abort");
+    }
+    if (rec.status === MultipartStatus.ABORTED) {
+      return { success: true, data: { uploadId: rec.id, status: "ABORTED", idempotent: true } };
+    }
+    try {
+      await rt.multipartRepo.markAborted(body.uploadId);
+    } catch (e) {
+      if (e.message === "ALREADY_COMPLETED") {
+        throw new SecureError(1521 /* MULTIPART_ALREADY_COMPLETED */, "\u5DF2\u5B8C\u6210\u7684 uploadId \u4E0D\u80FD abort");
+      }
+      if (e.message === "STATUS_INVALID") {
+        throw new SecureError(1524 /* MULTIPART_STATUS_INVALID */, "\u72B6\u6001\u673A\u975E\u6CD5\u8F6C\u79FB");
+      }
+      throw e;
+    }
+    rt.storage.cleanupMultipart(body.uploadId).catch((e) => {
+      req.log.warn({ err: e, uploadId: body.uploadId }, "\u26A0\uFE0F abort \u540E\u6E05\u7406\u5931\u8D25");
+    });
+    req.log.info({ uploadId: body.uploadId, userId: rec.userId }, "\u{1F6D1} multipart: abort");
+    return { success: true, data: { uploadId: rec.id, status: "ABORTED" } };
+  });
+  app.post(`${base}/status`, async (req, reply) => {
+    const body = StatusBodySchema.parse(req.body ?? {});
+    const rec = await rt.multipartRepo.findById(body.uploadId);
+    if (!rec) {
+      throw new SecureError(1520 /* MULTIPART_NOT_FOUND */, `uploadId \u4E0D\u5B58\u5728`);
+    }
+    if (!rec.isPublic) {
+      await resolveUserIdForRecord(req, rec.userId, rec.isPublic, rt);
+    }
+    const diskParts = await rt.storage.listParts(rec.id);
+    const diskSet = new Set(diskParts);
+    const dbSet = new Set(rec.receivedParts);
+    const mergedReceived = Array.from(/* @__PURE__ */ new Set([...diskSet, ...dbSet])).sort((a, b) => a - b);
+    return {
+      success: true,
+      data: {
+        uploadId: rec.id,
+        status: rec.status,
+        filename: rec.filename,
+        contentType: rec.contentType,
+        totalSize: Number(rec.totalSize),
+        partSize: rec.partSize,
+        totalParts: rec.totalParts,
+        receivedParts: mergedReceived,
+        receivedCount: mergedReceived.length,
+        isPublic: rec.isPublic,
+        expiresAt: rec.expiresAt.toISOString(),
+        createdAt: rec.createdAt.toISOString(),
+        completedAt: rec.completedAt?.toISOString() ?? null,
+        fileId: rec.fileId
+      }
+    };
+  });
+}
+async function resolveUserIdForRecord(req, expectedUserId, isPublic, rt) {
+  const sr = req.secureRequest;
+  const session = sr?.session ?? req.headers["x-secure-session"];
+  const userId = await rt.validateSession(session, isPublic);
+  if (!isPublic && userId !== expectedUserId) {
+    throw new SecureError(1400 /* NOT_FOUND */, "uploadId \u4E0D\u5B58\u5728");
+  }
+  return userId;
+}
+
+// src/server/routes/smart.ts
+var import_zod2 = require("zod");
+var FileInitItemSchema = import_zod2.z.object({
+  filename: import_zod2.z.string().min(1).max(255),
+  contentType: import_zod2.z.string().min(1).max(128).default("application/octet-stream"),
+  size: import_zod2.z.coerce.number().int().nonnegative(),
+  isPublic: import_zod2.z.coerce.boolean().default(false),
+  expectedHash: import_zod2.z.string().regex(/^[a-f0-9]{64}$/i).optional(),
+  meta: import_zod2.z.record(import_zod2.z.unknown()).optional()
+}).strict();
+var SmartInitBodySchema = import_zod2.z.object({
+  files: import_zod2.z.array(FileInitItemSchema).min(1).max(50)
+}).strict();
+async function processOneFile(req, rt, file, index) {
+  try {
+    const { userId } = await resolveSession(req, file.isPublic, rt.validateSession);
+    if (file.size > rt.config.fileMaxSize) {
+      throw new SecureError(
+        1530 /* MULTIPART_TOTAL_TOO_LARGE */,
+        `\u6587\u4EF6 ${file.filename} \u5927\u5C0F ${file.size} \u8D85\u8FC7\u5355\u6587\u4EF6\u9650\u5236 ${rt.config.fileMaxSize}`
+      );
+    }
+    if (file.expectedHash) {
+      const existing = await rt.fileRepo.findDedupCandidate(
+        file.expectedHash,
+        file.isPublic,
+        userId
+      );
+      if (existing) {
+        const diskOk = await rt.storage.exists(existing.storageKey).catch(() => false);
+        if (diskOk) {
+          req.log.info(
+            { hash: file.expectedHash, fileId: existing.id, isPublic: file.isPublic, userId, index },
+            "\u26A1 smart: \u79D2\u4F20\u547D\u4E2D(\u4E25\u683C\u5339\u914D\u53EF\u89C1\u6027+\u8EAB\u4EFD)"
+          );
+          return {
+            ok: true,
+            index,
+            filename: file.filename,
+            size: Number(existing.size),
+            dedup: true,
+            fileId: existing.id,
+            contentType: existing.contentType,
+            url: `${rt.config.fileUrlPrefix}/${existing.id}`
+          };
+        }
+        req.log.warn(
+          { hash: file.expectedHash, fileId: existing.id, userId, index },
+          "\u26A0\uFE0F smart: DB \u547D\u4E2D\u4F46\u78C1\u76D8\u4E22\u5931,\u653E\u5F03\u79D2\u4F20"
+        );
+        await rt.fileRepo.softDelete(existing.id, { orphanedAt: (/* @__PURE__ */ new Date()).toISOString() }).catch((e) => {
+          req.log.warn({ err: e, fileId: existing.id }, "\u26A0\uFE0F \u8F6F\u5220\u9664\u5B64\u513F record \u5931\u8D25");
+        });
+      }
+    }
+    const strategy = chooseStrategy(file.size, rt.config.strategy);
+    req.log.info(
+      {
+        index,
+        filename: file.filename,
+        size: file.size,
+        strategy: strategy.kind,
+        partSize: strategy.partSize,
+        totalParts: strategy.totalParts,
+        reason: strategy.reason
+      },
+      `\u{1F9E0} smart: \u9009\u7B56\u7565 ${strategy.kind}(${strategy.reason})`
+    );
+    const rec = await rt.multipartRepo.createInit({
+      userId,
+      filename: file.filename,
+      contentType: file.contentType,
+      totalSize: file.size,
+      partSize: strategy.partSize,
+      totalParts: strategy.totalParts,
+      isPublic: file.isPublic,
+      expectedHash: file.expectedHash ?? null,
+      meta: file.meta ?? null,
+      ttlSeconds: rt.config.ttlSeconds
+    });
+    return {
+      ok: true,
+      index,
+      filename: file.filename,
+      size: file.size,
+      dedup: false,
+      uploadId: rec.id,
+      contentType: file.contentType,
+      isPublic: file.isPublic,
+      partSize: strategy.partSize,
+      totalParts: strategy.totalParts,
+      totalSize: file.size,
+      strategy: strategy.kind,
+      suggestedConcurrency: suggestConcurrency(strategy),
+      expiresAt: rec.expiresAt.toISOString(),
+      ttl: rt.config.ttlSeconds
+    };
+  } catch (e) {
+    const code = e instanceof SecureError ? e.code : e?.code ?? 1001 /* INVALID_REQUEST */;
+    const message = e?.message ?? String(e);
+    const errName = e instanceof SecureError ? e.name : "INTERNAL_ERROR";
+    return {
+      ok: false,
+      index,
+      filename: file.filename,
+      code,
+      error: errName,
+      message
+    };
+  }
+}
+async function registerSmartRoutes(app, rt) {
+  if (!rt.config.enabled) {
+    app.log.warn("\u26A0\uFE0F  smart \u4E0A\u4F20\u5DF2\u7981\u7528 (enabled=false)");
+    return;
+  }
+  const base = rt.config.smartPath;
+  app.log.info(
+    {
+      routes: [`${base}/init`],
+      maxFiles: rt.config.smartMaxFiles,
+      rateLimit: rt.config.smartInitRateLimit
+    },
+    "\u{1F527} smart-routes: \u6CE8\u518C smart \u4E0A\u4F20\u8DEF\u7531(part/complete/abort/status \u590D\u7528 multipart/*)..."
+  );
+  app.post(`${base}/init`, async (req) => {
+    const body = SmartInitBodySchema.parse(req.body ?? {});
+    if (body.files.length > rt.config.smartMaxFiles) {
+      throw new SecureError(
+        1511 /* BATCH_TOO_MANY_FILES */,
+        `\u5355\u6B21 /smart/init \u6700\u591A ${rt.config.smartMaxFiles} \u4E2A\u6587\u4EF6,\u5B9E\u9645 ${body.files.length}`
+      );
+    }
+    const sessionKeyForRl = (() => {
+      const sr = req.secureRequest;
+      return sr?.session ?? req.headers["x-secure-session"] ?? "anonymous";
+    })();
+    const allPublic = body.files.every((f) => f.isPublic);
+    const userIdForRl = await resolveUserId(req, allPublic, rt.validateSession);
+    const rlKey = `rl:mp:init:${userIdForRl ?? sessionKeyForRl.slice(0, 32)}`;
+    for (let i = 0; i < body.files.length; i++) {
+      const rl = rt.redis ? await slidingWindowRateLimit(rt.redis, rlKey, 6e4, rt.config.smartInitRateLimit) : memorySlidingWindowRateLimit(rlKey, 6e4, rt.config.smartInitRateLimit);
+      if (!rl.ok) {
+        req.log.warn(
+          { remaining: 0, consumed: i, total: body.files.length, retryAfterMs: rl.retryAfterMs },
+          "\u26A0\uFE0F smart: \u6279\u91CF\u914D\u989D\u4E0D\u8DB3,\u540E\u7EED\u6587\u4EF6\u6807\u8BB0\u5931\u8D25"
+        );
+        const results2 = [];
+        for (let j = 0; j < i; j++) {
+          const r = await processOneFile(req, rt, body.files[j], j);
+          results2.push(r);
+        }
+        for (let j = i; j < body.files.length; j++) {
+          results2.push({
+            ok: false,
+            index: j,
+            filename: body.files[j].filename,
+            code: 1402 /* RATE_LIMITED */,
+            error: "RATE_LIMITED",
+            message: `\u6279\u91CF\u914D\u989D\u4E0D\u8DB3,\u9700 ${Math.ceil(rl.retryAfterMs / 1e3)}s \u540E\u91CD\u8BD5`
+          });
+        }
+        return {
+          success: true,
+          data: {
+            files: results2,
+            summary: {
+              total: body.files.length,
+              ok: results2.filter((r) => r.ok).length,
+              failed: results2.filter((r) => !r.ok).length,
+              dedup: results2.filter((r) => r.ok && r.dedup === true).length,
+              oneShot: results2.filter((r) => r.ok && r.dedup === false && r.strategy === "ONE_SHOT").length,
+              multipart: results2.filter((r) => r.ok && r.dedup === false && r.strategy === "MULTIPART").length,
+              rateLimited: body.files.length - i
+            }
+          }
+        };
+      }
+    }
+    const t0 = Date.now();
+    const results = [];
+    for (let i = 0; i < body.files.length; i++) {
+      const f = body.files[i];
+      const result = await processOneFile(req, rt, f, i);
+      results.push(result);
+    }
+    const summary = {
+      total: results.length,
+      ok: results.filter((r) => r.ok).length,
+      failed: results.filter((r) => !r.ok).length,
+      dedup: results.filter((r) => r.ok && r.dedup === true).length,
+      oneShot: results.filter((r) => r.ok && r.dedup === false && r.strategy === "ONE_SHOT").length,
+      multipart: results.filter((r) => r.ok && r.dedup === false && r.strategy === "MULTIPART").length
+    };
+    req.log.info(
+      { total: summary.total, ok: summary.ok, dedup: summary.dedup, oneShot: summary.oneShot, multipart: summary.multipart, ms: Date.now() - t0 },
+      "\u2705 smart: init \u6C47\u603B"
+    );
+    return { success: true, data: { files: results, summary } };
+  });
+}
+
+// src/server/utils/cleaner.ts
+function startMultipartCleanupTask(opts) {
+  if (!opts.enabled) {
+    opts.log.info("\u23F8\uFE0F  multipart-cleanup: \u5DF2\u7981\u7528");
+    return;
+  }
+  const intervalMs = opts.intervalSeconds * 1e3;
+  const tick = async () => {
+    try {
+      const expired = await opts.multipartRepo.listExpired(opts.batchLimit);
+      if (expired.length === 0) return;
+      opts.log.info({ count: expired.length }, "\u{1F9F9} multipart cleanup: \u53D1\u73B0\u8FC7\u671F uploadId");
+      for (const rec of expired) {
+        try {
+          await opts.multipartRepo.markExpired(rec.id);
+          await opts.storage.cleanupMultipart(rec.id);
+          opts.log.info({ uploadId: rec.id }, "\u{1F9F9} multipart cleanup: \u5DF2\u6E05\u7406");
+        } catch (e) {
+          opts.log.warn({ err: e, uploadId: rec.id }, "\u26A0\uFE0F multipart cleanup \u5355\u6761\u5931\u8D25");
+        }
+      }
+    } catch (e) {
+      opts.log.error({ err: e }, "\u274C multipart cleanup tick \u5931\u8D25");
+    }
+  };
+  setImmediate(tick);
+  const timer = setInterval(tick, intervalMs);
+  opts.onClose(() => clearInterval(timer));
+  opts.log.info(
+    { intervalSec: opts.intervalSeconds },
+    "\u{1F9F9} multipart cleanup task \u5DF2\u542F\u52A8"
+  );
+}
+
+// src/server/utils/orphan-scanner.ts
+function startOrphanFileScanTask(opts) {
+  if (!opts.enabled) {
+    opts.log.info("\u23F8\uFE0F  orphan-file-scan: \u5DF2\u7981\u7528");
+    return;
+  }
+  const intervalMs = opts.intervalSeconds * 1e3;
+  const batchSize = opts.batchSize;
+  const tick = async () => {
+    try {
+      const recent = await opts.fileRepo.listOrphans({
+        sinceDays: opts.lookbackDays,
+        limit: batchSize
+      });
+      if (recent.length === 0) {
+        opts.log.debug({ lookbackDays: opts.lookbackDays }, "\u{1F9F9} orphan-file-scan: \u65E0\u53EF\u626B\u8BB0\u5F55");
+        return;
+      }
+      let orphanCount = 0;
+      const samples = [];
+      for (const f of recent) {
+        try {
+          const ok = await opts.storage.exists(f.storageKey);
+          if (!ok) {
+            await opts.fileRepo.softDelete(f.id, { orphanedAt: (/* @__PURE__ */ new Date()).toISOString() });
+            orphanCount++;
+            if (samples.length < 5) {
+              samples.push({ fileId: f.id, storageKey: f.storageKey, size: Number(f.size) });
+            }
+          }
+        } catch (e) {
+          opts.log.warn(
+            { err: e, fileId: f.id, storageKey: f.storageKey },
+            "\u26A0\uFE0F orphan-file-scan: \u5355\u6761\u68C0\u6D4B\u5931\u8D25"
+          );
+        }
+      }
+      if (orphanCount > 0) {
+        opts.log.warn(
+          { scanned: recent.length, orphans: orphanCount, sample: samples },
+          "\u{1F9F9} orphan-file-scan: \u5B8C\u6210\u672C\u8F6E"
+        );
+      } else {
+        opts.log.info(
+          { scanned: recent.length, orphans: 0 },
+          "\u{1F9F9} orphan-file-scan: \u5B8C\u6210\u672C\u8F6E(\u5168\u90E8\u4E00\u81F4)"
+        );
+      }
+    } catch (e) {
+      opts.log.error({ err: e }, "\u274C orphan-file-scan tick \u5931\u8D25");
+    }
+  };
+  setImmediate(tick);
+  const timer = setInterval(tick, intervalMs);
+  opts.onClose(() => clearInterval(timer));
+  opts.log.info(
+    {
+      intervalSec: opts.intervalSeconds,
+      lookbackDays: opts.lookbackDays,
+      batchSize
+    },
+    "\u{1F9F9} orphan-file-scan task \u5DF2\u542F\u52A8"
+  );
+}
+
+// src/server/fastify-plugin.ts
+var KB = 1024;
+var MB = 1024 * KB;
+var GB = 1024 * MB;
+var DEFAULTS = {
+  enabled: true,
+  fileMaxSize: 5 * GB,
+  partMin: 5 * MB,
+  partMax: 50 * MB,
+  partDefault: 20 * MB,
+  ttlSeconds: 24 * 60 * 60,
+  suggestedConcurrency: 3,
+  initRateLimit: 30,
+  partRateLimit: 600,
+  smartMaxFiles: 50,
+  smartInitRateLimit: 30,
+  multipartPath: "/multipart",
+  smartPath: "/smart",
+  fileUrlPrefix: "/files",
+  secure: "raw"
+};
+async function resolveStorage(cfg) {
+  if (typeof cfg === "object" && "put" in cfg && typeof cfg.put === "function") {
+    return cfg;
+  }
+  const preset = cfg;
+  if (preset.adapter === "local") {
+    return new LocalStorage(preset.options.baseDir);
+  }
+  throw new Error(`[secure-upload-sdk] \u672A\u77E5\u7684 storage.adapter: ${preset.adapter}`);
+}
+function resolveRepository(cfg) {
+  if (cfg.kind === "prisma") {
+    return {
+      multipart: new PrismaMultipartRepository(cfg.prisma),
+      file: new PrismaFileRepository(cfg.prisma)
+    };
+  }
+  return { multipart: cfg.multipart, file: cfg.file };
+}
+async function secureUploadPluginImpl(app, options) {
+  if (!options.storage) {
+    throw new Error("[secure-upload-sdk] options.storage \u5FC5\u586B");
+  }
+  if (!options.repository) {
+    throw new Error("[secure-upload-sdk] options.repository \u5FC5\u586B");
+  }
+  const storage = await resolveStorage(options.storage);
+  const { multipart: multipartRepo, file: fileRepo } = resolveRepository(options.repository);
+  const runtime = {
+    storage,
+    multipartRepo,
+    fileRepo,
+    redis: options.redis ?? null,
+    config: {
+      enabled: options.enabled ?? DEFAULTS.enabled,
+      secure: options.secure?.mode ?? DEFAULTS.secure,
+      fileMaxSize: options.fileMaxSize ?? DEFAULTS.fileMaxSize,
+      partMin: options.partSize?.min ?? DEFAULTS.partMin,
+      partMax: options.partSize?.max ?? DEFAULTS.partMax,
+      partDefault: options.partSize?.default ?? DEFAULTS.partDefault,
+      ttlSeconds: options.ttlSeconds ?? DEFAULTS.ttlSeconds,
+      suggestedConcurrency: options.suggestedClientConcurrency ?? DEFAULTS.suggestedConcurrency,
+      initRateLimit: options.rateLimit?.initPerMin ?? DEFAULTS.initRateLimit,
+      partRateLimit: options.rateLimit?.partPerMin ?? DEFAULTS.partRateLimit,
+      smartMaxFiles: options.rateLimit?.smartMaxFilesPerInit ?? DEFAULTS.smartMaxFiles,
+      smartInitRateLimit: DEFAULTS.smartInitRateLimit,
+      multipartPath: options.pathPrefix?.multipart ?? DEFAULTS.multipartPath,
+      smartPath: options.pathPrefix?.smart ?? DEFAULTS.smartPath,
+      fileUrlPrefix: options.fileUrlPrefix ?? DEFAULTS.fileUrlPrefix,
+      strategy: {
+        ...DEFAULT_STRATEGY_CONFIG,
+        ...options.strategy ?? {}
+      }
+    },
+    validateSession: options.sessionValidator ?? defaultSessionValidator
+  };
+  app.decorate("secureUpload", runtime);
+  await registerMultipartRoutes(app, runtime);
+  await registerSmartRoutes(app, runtime);
+  app.setErrorHandler(function(err, req, reply) {
+    if (err instanceof SecureError) {
+      return reply.status(err.statusCode).send({
+        success: false,
+        code: err.code,
+        error: err.name,
+        message: err.message
+      });
+    }
+    const anyErr = err;
+    if (anyErr && typeof anyErr === "object" && "issues" in anyErr && Array.isArray(anyErr.issues)) {
+      return reply.status(400).send({
+        success: false,
+        code: 1001,
+        // INVALID_REQUEST
+        error: "ZodValidationError",
+        message: anyErr.issues?.[0]?.message ?? "invalid request"
+      });
+    }
+    app.log.error({ err }, "\u274C secure-upload-sdk \u9519\u8BEF");
+    return reply.status(anyErr?.statusCode ?? 500).send({
+      success: false,
+      code: 1500,
+      // INTERNAL_ERROR
+      error: anyErr?.name ?? "INTERNAL_ERROR",
+      message: anyErr?.message ?? "internal error"
+    });
+  });
+  if (options.cleanupTask?.enabled !== false) {
+    startMultipartCleanupTask({
+      enabled: true,
+      intervalSeconds: options.cleanupTask?.intervalSeconds ?? 300,
+      batchLimit: options.cleanupTask?.batchLimit ?? 100,
+      storage,
+      multipartRepo,
+      log: app.log,
+      onClose: (cb) => app.addHook("onClose", async () => cb())
+    });
+  }
+  if (options.orphanScan?.enabled !== false) {
+    startOrphanFileScanTask({
+      enabled: true,
+      intervalSeconds: options.orphanScan?.intervalSeconds ?? 300,
+      lookbackDays: options.orphanScan?.lookbackDays ?? 7,
+      batchSize: options.orphanScan?.batchSize ?? 2e3,
+      storage,
+      fileRepo,
+      log: app.log,
+      onClose: (cb) => app.addHook("onClose", async () => cb())
+    });
+  }
+  app.log.info(
+    {
+      secure: runtime.config.secure,
+      storage: storage.constructor.name,
+      repository: options.repository.kind,
+      redis: options.redis ? "yes" : "memory-fallback",
+      multipartPath: runtime.config.multipartPath,
+      smartPath: runtime.config.smartPath
+    },
+    "\u{1F680} secure-upload-fastify-sdk \u63D2\u4EF6\u5DF2\u6CE8\u518C"
+  );
+}
+var fastify_plugin_default = (0, import_fastify_plugin.default)(secureUploadPluginImpl, {
+  name: "secure-upload-fastify-sdk",
+  fastify: "4.x"
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorCode,
+  InMemoryFileRepository,
+  InMemoryMultipartRepository,
+  InMemoryStorage,
+  LocalStorage,
+  PrismaFileRepository,
+  PrismaMultipartRepository,
+  SecureError,
+  getHttpStatus,
+  secureUploadPlugin
+});
+//# sourceMappingURL=index.js.map