@stacksjs/storage 0.70.87 → 0.70.88

package/dist/index.js

@@ -1,2810 +0,0 @@
-// @bun
-var __require = import.meta.require;
-
-// src/copy.ts
-import { contains } from "@stacksjs/arrays";
-import { join } from "@stacksjs/path";
-
-// src/fs.ts
-import * as fs from "fs";
-import { existsSync, watch as fsWatch, mkdirSync, readFileSync, watchFile, writeFileSync } from "fs";
-function exists(path) {
-  return existsSync(path);
-}
-
-// src/copy.ts
-function copy(src, dest, exclude = []) {
-  if (Array.isArray(src)) {
-    src.forEach((file) => {
-      copy(file, dest, exclude);
-    });
-  } else {
-    if (fs.statSync(src).isDirectory())
-      copyFolder(src, dest, exclude);
-    else
-      copyFile(src, dest);
-  }
-}
-function copyFile(src, dest) {
-  fs.copyFileSync(src, dest);
-}
-function copyFolder(src, dest, exclude = []) {
-  if (!fs.existsSync(dest))
-    fs.mkdirSync(dest, { recursive: true });
-  if (fs.existsSync(src)) {
-    fs.readdirSync(src).forEach((file) => {
-      if (!contains(join(src, file), exclude)) {
-        const srcPath = join(src, file);
-        const destPath = join(dest, file);
-        if (fs.statSync(srcPath).isDirectory())
-          copyFolder(srcPath, destPath, exclude);
-        else
-          fs.copyFileSync(srcPath, destPath);
-      }
-    });
-  }
-}
-// src/delete.ts
-import { italic, log } from "@stacksjs/cli";
-import { err, handleError, ok } from "@stacksjs/error-handling";
-import { join as join3 } from "@stacksjs/path";
-
-// src/folders.ts
-import { join as join2 } from "@stacksjs/path";
-function isFolder(path) {
-  try {
-    return fs.statSync(path).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function isDir(path) {
-  return isFolder(path);
-}
-function doesFolderExist(path) {
-  return fs.existsSync(path);
-}
-function createFolder(dir) {
-  return new Promise((resolve, reject) => {
-    try {
-      fs.mkdirSync(dir, { recursive: true });
-      resolve();
-    } catch (err) {
-      reject(err);
-    }
-  });
-}
-function getFolders(dir) {
-  return fs.readdirSync(dir).filter((file) => {
-    return fs.statSync(join2(dir, file)).isDirectory();
-  });
-}
-var folders = {
-  isFolder,
-  doesFolderExist,
-  createFolder,
-  getFolders
-};
-
-// src/glob.ts
-var {Glob: BunGlob } = globalThis.Bun;
-function isEnoent(err) {
-  return !!err && typeof err === "object" && err.code === "ENOENT";
-}
-function globSync(patterns, options) {
-  const patternArray = typeof patterns === "string" ? [patterns] : patterns;
-  const results = [];
-  for (const pattern of patternArray) {
-    try {
-      const globInstance = new BunGlob(pattern);
-      const matches = globInstance.scanSync({
-        cwd: options?.cwd,
-        absolute: options?.absolute,
-        dot: options?.dot,
-        onlyFiles: options?.onlyFiles
-      });
-      for (const match of matches) {
-        results.push(match);
-      }
-    } catch (err) {
-      if (!isEnoent(err))
-        throw err;
-    }
-  }
-  return results;
-}
-async function glob(patterns, options) {
-  const patternArray = typeof patterns === "string" ? [patterns] : patterns;
-  const results = [];
-  for (const pattern of patternArray) {
-    try {
-      const globInstance = new BunGlob(pattern);
-      const matches = globInstance.scan({
-        cwd: options?.cwd,
-        absolute: options?.absolute,
-        dot: options?.dot,
-        onlyFiles: options?.onlyFiles
-      });
-      for await (const match of matches) {
-        results.push(match);
-      }
-    } catch (err) {
-      if (!isEnoent(err))
-        throw err;
-    }
-  }
-  return results;
-}
-
-// src/delete.ts
-function deleteFolder(path) {
-  return new Promise((resolve, reject) => {
-    try {
-      if (isFolder(path)) {
-        fs.rmSync(path, { recursive: true, force: true });
-        return resolve(ok(`Deleted ${path}`));
-      }
-      return resolve(ok(`Path ${path} was not a directory`));
-    } catch (error) {
-      return reject(err(error));
-    }
-  });
-}
-async function isDirectoryEmpty(path) {
-  return new Promise((resolve, reject) => {
-    try {
-      if (fs.statSync(path).isDirectory()) {
-        if (fs.readdirSync(path).length === 0)
-          return resolve(ok(true));
-        return resolve(ok(false));
-      }
-      return resolve(ok(false));
-    } catch (error) {
-      return reject(err(error));
-    }
-  });
-}
-async function deleteEmptyFolder(path) {
-  return new Promise((resolve, reject) => {
-    try {
-      if (fs.statSync(path).isDirectory()) {
-        if (fs.readdirSync(path).length === 0) {
-          fs.rmSync(path, { recursive: true, force: true });
-          return resolve(ok(`Deleted ${path}`));
-        }
-        return resolve(ok(`Path ${path} was not empty`));
-      }
-      return resolve(ok(`Path ${path} was not a directory`));
-    } catch (error) {
-      return reject(err(error));
-    }
-  });
-}
-async function deleteEmptyFolders(dir) {
-  try {
-    if (!fs.existsSync(dir))
-      return ok(`Path ${dir} does not exist`);
-    const files = fs.readdirSync(dir);
-    for (const file of files) {
-      const p = join3(dir, file);
-      if (isFolder(p)) {
-        if (fs.readdirSync(p).length === 0)
-          fs.rmSync(p, { recursive: true, force: true });
-        else
-          await deleteEmptyFolders(p);
-      }
-    }
-    return ok(`Deleted empty folders located in ${dir}`);
-  } catch (error) {
-    return err(error);
-  }
-}
-function deleteFile(path) {
-  return new Promise((resolve, reject) => {
-    try {
-      if (fs.statSync(path).isFile()) {
-        fs.rmSync(path, { recursive: true, force: true });
-        return resolve(ok(`Deleted ${path}`));
-      }
-      return resolve(ok(`Path ${path} was not a file`));
-    } catch (error) {
-      return reject(err(error));
-    }
-  });
-}
-async function deleteGlob(path) {
-  if (!path.includes("*"))
-    return err(handleError(`Path ${path} does not contain a glob`));
-  const directories = await glob([path], { onlyDirectories: true });
-  for (const directory of directories) {
-    const result = await deleteFolder(directory);
-    if (result.isErr) {
-      log.error(result.error);
-      return result;
-    }
-    log.info(`Deleted ${italic(directory)}`);
-  }
-  return ok(`Deleted ${directories.length} directories`);
-}
-async function del(path) {
-  if (fs.existsSync(path) && fs.statSync(path).isFile())
-    return await deleteFile(path);
-  if (isFolder(path))
-    return await deleteFolder(path);
-  if (path.includes("*"))
-    return await deleteGlob(path);
-  return err(handleError(`Path ${path} cannot be deleted due to an unhandled condition. Please report this issue.`));
-}
-// src/files.ts
-import { contains as contains2 } from "@stacksjs/arrays";
-import { log as log2 } from "@stacksjs/logging";
-import { dirname, join as join4, path as p } from "@stacksjs/path";
-import { detectIndent, detectNewline } from "@stacksjs/strings";
-async function readJsonFile(name, cwd) {
-  const file = await readTextFile(name, cwd);
-  let data;
-  try {
-    data = JSON.parse(file.data);
-  } catch (error) {
-    throw new Error(`Failed to parse JSON file "${name}": ${error.message}`);
-  }
-  const indent = detectIndent(file.data).indent;
-  const newline = detectNewline(file.data);
-  return { ...file, data, indent, newline };
-}
-async function readPackageJson(name, cwd) {
-  const file = await readJsonFile(name, cwd);
-  return file.data;
-}
-async function writeFile(path, data) {
-  if (typeof path === "string") {
-    const dirPath = dirname(path);
-    if (!await existsSync(dirPath))
-      await createFolder(dirPath);
-    return await Bun.write(Bun.file(path), data);
-  }
-  return await Bun.write(path, data);
-}
-async function writeJsonFile(file) {
-  let json = JSON.stringify(file.data, undefined, file.indent);
-  if (file.newline)
-    json += file.newline;
-  return writeTextFile({ ...file, data: json });
-}
-function readTextFile(name, cwd) {
-  return new Promise((resolve, reject) => {
-    let filePath;
-    if (cwd)
-      filePath = join4(cwd, name);
-    else
-      filePath = name;
-    fs.readFile(filePath, "utf8", (err2, text) => {
-      if (err2) {
-        reject(err2);
-      } else {
-        resolve({
-          path: filePath,
-          data: text
-        });
-      }
-    });
-  });
-}
-async function writeTextFile(file) {
-  return await Bun.write(file.path, file.data);
-}
-function isFile(path) {
-  return fs.existsSync(path);
-}
-function doesExist(path) {
-  return isFile(path) || isFolder(path);
-}
-function doesNotExist(path) {
-  return !isFile(path) && !isFolder(path);
-}
-function hasFiles(folder) {
-  try {
-    return fs.readdirSync(folder).length > 0;
-  } catch (err2) {
-    log2.debug(`Error reading folder: ${folder}`, err2);
-    return false;
-  }
-}
-function hasComponents() {
-  return hasFiles(p.componentsPath());
-}
-function hasFunctions() {
-  return hasFiles(p.functionsPath());
-}
-function deleteFiles(dir, exclude = []) {
-  if (fs.existsSync(dir)) {
-    fs.readdirSync(dir).forEach((file) => {
-      const p2 = join4(dir, file);
-      if (fs.statSync(p2).isDirectory()) {
-        if (fs.readdirSync(p2).length === 0)
-          fs.rmSync(p2, { recursive: true, force: true });
-        else
-          deleteFiles(p2, exclude);
-      } else if (!contains2(p2, exclude)) {
-        fs.rmSync(p2);
-      }
-    });
-  }
-}
-function getFiles(dir, exclude = []) {
-  let results = [];
-  const list = fs.readdirSync(dir);
-  list.forEach((file) => {
-    file = join4(dir, file);
-    const stat = fs.statSync(file);
-    if (stat.isDirectory())
-      results = results.concat(getFiles(file, exclude));
-    else if (!contains2(file, exclude))
-      results.push(file);
-  });
-  return results;
-}
-function put(path, contents) {
-  const dirPath = dirname(path);
-  if (!fs.existsSync(dirPath))
-    fs.mkdirSync(dirPath, { recursive: true });
-  fs.writeFileSync(path, contents, "utf-8");
-}
-async function get(path) {
-  return Bun.file(path).text();
-}
-var files = {
-  readJsonFile,
-  readPackageJson,
-  readTextFile,
-  writeJsonFile,
-  writeTextFile,
-  hasFiles,
-  hasComponents,
-  hasFunctions,
-  deleteFiles,
-  getFiles,
-  put,
-  get
-};
-// src/hash.ts
-import { createHash } from "crypto";
-import { path as p2 } from "@stacksjs/path";
-function hashFileOrDirectory(path, hash) {
-  if (!fs.existsSync(path)) {
-    console.error(`Path does not exist: ${path}`);
-    return;
-  }
-  if (fs.statSync(path).isDirectory()) {
-    const files2 = fs.readdirSync(path);
-    for (const file of files2) {
-      const filePath = p2.join(path, file);
-      hashFileOrDirectory(filePath, hash);
-    }
-  } else {
-    hash.update(fs.readFileSync(path));
-  }
-}
-function hashDirectory(directory) {
-  const hash = createHash("sha256");
-  hashFileOrDirectory(directory, hash);
-  return hash.digest("hex");
-}
-function hashPath(path) {
-  const hash = createHash("sha256");
-  hashFileOrDirectory(path, hash);
-  return hash.digest("hex");
-}
-function hashPaths(paths) {
-  const hash = createHash("sha256");
-  const pathsArray = Array.isArray(paths) ? paths : [paths];
-  for (const path of pathsArray)
-    hashFileOrDirectory(path, hash);
-  return hash.digest("hex");
-}
-// src/helpers.ts
-import { fileURLToPath } from "url";
-import { dirname as dirname2 } from "@stacksjs/path";
-var __dirname = "/home/runner/work/stacks/stacks/storage/framework/core/storage/src";
-var _dirname = typeof __dirname !== "undefined" ? __dirname : dirname2(fileURLToPath(import.meta.url));
-function updateConfigFile(filePath, newConfig) {
-  return new Promise((resolve, reject) => {
-    let config;
-    try {
-      config = JSON.parse(fs.readFileSync(filePath, "utf8"));
-    } catch (error) {
-      reject(new Error(`Failed to parse config file "${filePath}": ${error.message}`));
-      return;
-    }
-    for (const key in newConfig)
-      config[key] = newConfig[key];
-    try {
-      fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
-      resolve();
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-var helpers = {
-  _dirname,
-  updateConfigFile
-};
-// src/zip.ts
-import { runCommand } from "@stacksjs/cli";
-function shellEscape(_arg) {
-  return `'${_arg.replace(/'/g, "'\\''")}'`;
-}
-async function zip(from, to, options) {
-  const toPath = to || "archive.zip";
-  if (Array.isArray(from)) {
-    const fromPath = from.map((f) => shellEscape(f)).join(" ");
-    return runCommand(`zip -r ${shellEscape(toPath)} ${fromPath}`, options);
-  }
-  return runCommand(`zip -r ${shellEscape(toPath)} ${shellEscape(from)}`, options);
-}
-async function unzip(paths) {
-  if (Array.isArray(paths))
-    return runCommand(`unzip ${paths.map((p3) => shellEscape(p3)).join(" ")}`);
-  return runCommand(`unzip ${shellEscape(paths)}`);
-}
-function archive(paths) {
-  return zip(paths);
-}
-function unarchive(paths) {
-  return unzip(paths);
-}
-function compress(paths) {
-  return zip(paths);
-}
-function decompress(paths) {
-  return unzip(paths);
-}
-function gzipSync(data, options) {
-  return Bun.gzipSync(data, options);
-}
-function gunzipSync(data) {
-  return Bun.gunzipSync(data);
-}
-function deflateSync(data, options) {
-  return Bun.deflateSync(data, options);
-}
-function inflateSync(data) {
-  return Bun.inflateSync(data);
-}
-// src/adapters/local.ts
-import { Buffer as Buffer2 } from "buffer";
-import { createHmac as createHmac2 } from "crypto";
-import { createReadStream, createWriteStream } from "fs";
-import { access, chmod, constants, copyFile as copyFile2, lstat, mkdir, readdir, readFile, rename, rm, stat, unlink, writeFile as writeFile2 } from "fs/promises";
-import { basename, dirname as dirname3, join as join5, relative } from "path";
-import { Readable } from "stream";
-import { pipeline } from "stream/promises";
-
-// src/types.ts
-var Visibility;
-((Visibility2) => {
-  Visibility2["PUBLIC"] = "public";
-  Visibility2["PRIVATE"] = "private";
-})(Visibility ||= {});
-async function* createDirectoryListing(entries) {
-  for (const entry of entries) {
-    yield entry;
-  }
-}
-function normalizeExpiryToMilliseconds(expiry) {
-  if (expiry instanceof Date) {
-    return expiry.getTime() - Date.now();
-  }
-  return expiry * 1000;
-}
-function normalizeExpiryToDate(expiry) {
-  if (expiry instanceof Date) {
-    return expiry;
-  }
-  return new Date(Date.now() + expiry * 1000);
-}
-function isFile2(entry) {
-  return entry.type === "file";
-}
-function isDirectory(entry) {
-  return entry.type === "directory";
-}
-
-// src/signed-url.ts
-import { Buffer } from "buffer";
-import { createHmac, timingSafeEqual } from "crypto";
-import process2 from "process";
-var ALG = "HS256";
-function getAppKey() {
-  const k = process2.env.APP_KEY;
-  if (!k || k.length < 16) {
-    if (process2.env.APP_ENV === "production" || process2.env.NODE_ENV === "production") {
-      throw new Error("[storage/signed-url] APP_KEY is missing or too short (need \u226516 chars). Cannot sign URL.");
-    }
-  }
-  return k || "stacks-default-key-dev-only-do-not-use-prod";
-}
-function base64UrlEncode(buf) {
-  return buf.toString("base64url");
-}
-function normalizeExpiry(expiresIn) {
-  if (expiresIn instanceof Date)
-    return Math.floor(expiresIn.getTime() / 1000);
-  return Math.floor(Date.now() / 1000) + Math.floor(expiresIn);
-}
-function createSignedStorageToken(path, options) {
-  const exp = normalizeExpiry(options.expiresIn);
-  const iat = Math.floor(Date.now() / 1000);
-  const header = { alg: ALG, typ: "JWT" };
-  const payload = {
-    iss: options.issuer || "stacks",
-    iat,
-    exp,
-    path
-  };
-  const headerPart = base64UrlEncode(Buffer.from(JSON.stringify(header)));
-  const payloadPart = base64UrlEncode(Buffer.from(JSON.stringify(payload)));
-  const signingInput = `${headerPart}.${payloadPart}`;
-  const sig = base64UrlEncode(createHmac("sha256", getAppKey()).update(signingInput).digest());
-  return `${signingInput}.${sig}`;
-}
-var revokedSignatures = new Set;
-
-// src/adapters/local.ts
-class LocalStorageAdapter {
-  root;
-  constructor(config = {}) {
-    this.root = config.root || process.cwd();
-  }
-  resolvePath(path) {
-    const resolved = join5(this.root, path);
-    const rel = relative(this.root, resolved);
-    if (rel.startsWith("..") || rel.startsWith("../") || rel.startsWith("..\\")) {
-      throw new Error(`Path traversal detected: '${path}' resolves outside storage root`);
-    }
-    return resolved;
-  }
-  async write(path, contents) {
-    const fullPath = this.resolvePath(path);
-    const dir = dirname3(fullPath);
-    await mkdir(dir, { recursive: true });
-    if (typeof contents === "string") {
-      await writeFile2(fullPath, contents, "utf8");
-    } else if (contents instanceof Buffer2) {
-      await writeFile2(fullPath, contents);
-    } else if (contents instanceof Uint8Array) {
-      await writeFile2(fullPath, contents);
-    } else {
-      const writeStream = createWriteStream(fullPath);
-      await pipeline(contents, writeStream);
-    }
-    const st = await stat(fullPath);
-    return {
-      path,
-      size: st.size,
-      lastModified: st.mtimeMs
-    };
-  }
-  async read(path) {
-    const fullPath = this.resolvePath(path);
-    return await readFile(fullPath);
-  }
-  async getStream(path, options) {
-    const fullPath = this.resolvePath(path);
-    await access(fullPath, constants.R_OK);
-    const nodeStream = createReadStream(fullPath, { signal: options?.signal });
-    return Readable.toWeb(nodeStream);
-  }
-  async putStream(path, stream, options) {
-    const fullPath = this.resolvePath(path);
-    const dir = dirname3(fullPath);
-    await mkdir(dir, { recursive: true });
-    const nodeReadable = Readable.fromWeb(stream);
-    const writeStream = createWriteStream(fullPath);
-    try {
-      await pipeline(nodeReadable, writeStream, { signal: options?.signal });
-    } catch (err2) {
-      try {
-        await unlink(fullPath);
-      } catch {}
-      throw err2;
-    }
-    const st = await stat(fullPath);
-    return {
-      path,
-      size: st.size,
-      contentType: options?.contentType,
-      lastModified: st.mtimeMs
-    };
-  }
-  async readToString(path) {
-    const fullPath = this.resolvePath(path);
-    return await readFile(fullPath, "utf8");
-  }
-  async readToBuffer(path) {
-    const fullPath = this.resolvePath(path);
-    return await readFile(fullPath);
-  }
-  async readToUint8Array(path) {
-    const fullPath = this.resolvePath(path);
-    const buffer = await readFile(fullPath);
-    return new Uint8Array(buffer);
-  }
-  async deleteFile(path) {
-    const fullPath = this.resolvePath(path);
-    await unlink(fullPath);
-  }
-  async deleteDirectory(path) {
-    const fullPath = this.resolvePath(path);
-    await rm(fullPath, { recursive: true, force: true });
-  }
-  async createDirectory(path) {
-    const fullPath = this.resolvePath(path);
-    await mkdir(fullPath, { recursive: true });
-  }
-  async moveFile(from, to) {
-    const fromPath = this.resolvePath(from);
-    const toPath = this.resolvePath(to);
-    const toDir = dirname3(toPath);
-    await mkdir(toDir, { recursive: true });
-    await rename(fromPath, toPath);
-  }
-  async copyFile(from, to) {
-    const fromPath = this.resolvePath(from);
-    const toPath = this.resolvePath(to);
-    const toDir = dirname3(toPath);
-    await mkdir(toDir, { recursive: true });
-    await copyFile2(fromPath, toPath);
-  }
-  async stat(path) {
-    const fullPath = this.resolvePath(path);
-    const stats = await lstat(fullPath);
-    return {
-      path,
-      type: stats.isDirectory() ? "directory" : "file",
-      visibility: await this.visibility(path),
-      size: stats.size,
-      lastModified: stats.mtimeMs,
-      mimeType: stats.isFile() ? await this.detectMimeType(fullPath) : undefined
-    };
-  }
-  list(path, options = {}) {
-    return this.createAsyncIterator(path, options.deep || false);
-  }
-  async* createAsyncIterator(path, deep) {
-    const fullPath = this.resolvePath(path);
-    try {
-      await access(fullPath, constants.R_OK);
-    } catch {
-      return;
-    }
-    const entries = await this.readDirectoryRecursive(fullPath, deep);
-    yield* createDirectoryListing(entries);
-  }
-  async readDirectoryRecursive(dirPath, deep) {
-    const entries = [];
-    try {
-      const items = await readdir(dirPath, { withFileTypes: true });
-      for (const item of items) {
-        const itemPath = join5(dirPath, item.name);
-        const relativePath = relative(this.root, itemPath);
-        entries.push({
-          path: relativePath,
-          type: item.isDirectory() ? "directory" : "file"
-        });
-        if (deep && item.isDirectory()) {
-          const subEntries = await this.readDirectoryRecursive(itemPath, true);
-          entries.push(...subEntries);
-        }
-      }
-    } catch (error) {
-      if (error?.code !== "EACCES" && error?.code !== "EPERM") {
-        throw error;
-      }
-    }
-    return entries;
-  }
-  async changeVisibility(path, vis) {
-    const fullPath = this.resolvePath(path);
-    const stats = await lstat(fullPath);
-    const isDir2 = stats.isDirectory();
-    const mode = vis === "public" ? isDir2 ? 493 : 420 : isDir2 ? 448 : 384;
-    await chmod(fullPath, mode);
-  }
-  async visibility(path) {
-    const fullPath = this.resolvePath(path);
-    const stats = await lstat(fullPath);
-    const perms = stats.mode & 511;
-    return perms & 4 ? "public" : "private";
-  }
-  async fileExists(path) {
-    const fullPath = this.resolvePath(path);
-    try {
-      const stats = await lstat(fullPath);
-      return stats.isFile();
-    } catch {
-      return false;
-    }
-  }
-  async directoryExists(path) {
-    const fullPath = this.resolvePath(path);
-    try {
-      const stats = await lstat(fullPath);
-      return stats.isDirectory();
-    } catch {
-      return false;
-    }
-  }
-  async publicUrl(path, options = {}) {
-    const base = (options.domain || process.env.APP_URL || "http://localhost").replace(/\/$/, "");
-    return `${base}/${path}`;
-  }
-  async temporaryUrl(path, options) {
-    const expiry = normalizeExpiryToDate(options.expiresIn);
-    const payload = `${path}:${expiry.getTime()}`;
-    const appKey = process.env.APP_KEY || "stacks-default-key";
-    const signature = createHmac2("sha256", appKey).update(payload).digest("hex");
-    const token = Buffer2.from(`${payload}:${signature}`).toString("base64url");
-    return `http://localhost/temp/${token}`;
-  }
-  async signedUrl(path, options) {
-    const token = createSignedStorageToken(path, options);
-    const baseUrl = (options.baseUrl || process.env.APP_URL || "http://localhost").replace(/\/$/, "");
-    return `${baseUrl}/__storage/${encodeURIComponent(path)}?token=${token}`;
-  }
-  async checksum(path, options = {}) {
-    const algorithm = options.algorithm || "sha256";
-    const fullPath = this.resolvePath(path);
-    const content = await readFile(fullPath);
-    const hasher = new Bun.CryptoHasher(algorithm);
-    hasher.update(content);
-    return hasher.digest("hex");
-  }
-  async mimeType(path, options = {}) {
-    const fullPath = this.resolvePath(path);
-    return await this.detectMimeType(fullPath);
-  }
-  async detectMimeType(filePath) {
-    const ext = basename(filePath).split(".").pop()?.toLowerCase();
-    const mimeTypes = {
-      txt: "text/plain",
-      html: "text/html",
-      css: "text/css",
-      js: "application/javascript",
-      json: "application/json",
-      xml: "application/xml",
-      pdf: "application/pdf",
-      zip: "application/zip",
-      jpg: "image/jpeg",
-      jpeg: "image/jpeg",
-      png: "image/png",
-      gif: "image/gif",
-      svg: "image/svg+xml",
-      mp4: "video/mp4",
-      mp3: "audio/mpeg",
-      wav: "audio/wav"
-    };
-    return mimeTypes[ext || ""] || "application/octet-stream";
-  }
-  async lastModified(path) {
-    const stats = await this.stat(path);
-    return stats.lastModified;
-  }
-  async fileSize(path) {
-    const stats = await this.stat(path);
-    return stats.size;
-  }
-}
-function createLocalStorage(config = {}) {
-  return new LocalStorageAdapter(config);
-}
-
-// src/adapters/memory.ts
-import { Buffer as Buffer3 } from "buffer";
-import { basename as basename2 } from "path";
-class InMemoryStorageAdapter {
-  files;
-  directories;
-  constructor() {
-    this.files = new Map;
-    this.directories = new Set;
-    this.directories.add("");
-  }
-  normalizePath(path) {
-    return path.replace(/^\/+/, "").replace(/\/+$/, "");
-  }
-  getDirectoryPath(path) {
-    const parts = path.split("/").filter(Boolean);
-    parts.pop();
-    return parts.join("/");
-  }
-  async contentsToUint8Array(contents) {
-    if (typeof contents === "string") {
-      return new TextEncoder().encode(contents);
-    } else if (contents instanceof Buffer3) {
-      return new Uint8Array(contents);
-    } else if (contents instanceof Uint8Array) {
-      return contents;
-    } else {
-      const stream = contents;
-      if (typeof stream.getReader !== "function") {
-        throw new TypeError("[storage/memory] contents must be a web-standard ReadableStream " + "(with .getReader()), not a Node stream.Readable. " + "Convert via Readable.toWeb(nodeStream) before passing.");
-      }
-      const reader = contents.getReader();
-      const chunks = [];
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        if (value)
-          chunks.push(value);
-      }
-      const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-      const result = new Uint8Array(totalLength);
-      let offset = 0;
-      for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.length;
-      }
-      return result;
-    }
-  }
-  async write(path, contents) {
-    const normalized = this.normalizePath(path);
-    const dirPath = this.getDirectoryPath(normalized);
-    if (dirPath) {
-      await this.createDirectory(dirPath);
-    }
-    const data = await this.contentsToUint8Array(contents);
-    const lastModified = Date.now();
-    const mimeType = this.detectMimeType(normalized);
-    this.files.set(normalized, {
-      contents: data,
-      visibility: "private",
-      mimeType,
-      lastModified
-    });
-    return {
-      path: normalized,
-      size: data.length,
-      contentType: mimeType,
-      lastModified
-    };
-  }
-  async read(path) {
-    const normalized = this.normalizePath(path);
-    const file = this.files.get(normalized);
-    if (!file) {
-      throw new Error(`File not found: ${path}`);
-    }
-    return file.contents;
-  }
-  async getStream(path, _options) {
-    const normalized = this.normalizePath(path);
-    const file = this.files.get(normalized);
-    if (!file)
-      throw new Error(`File not found: ${path}`);
-    const bytes = file.contents;
-    return new ReadableStream({
-      start(controller) {
-        controller.enqueue(bytes);
-        controller.close();
-      }
-    });
-  }
-  async putStream(path, stream, options) {
-    const normalized = this.normalizePath(path);
-    const dirPath = this.getDirectoryPath(normalized);
-    if (dirPath)
-      await this.createDirectory(dirPath);
-    const chunks = [];
-    const reader = stream.getReader();
-    const abort = options?.signal;
-    try {
-      while (true) {
-        if (abort?.aborted)
-          throw new Error("aborted");
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        if (value)
-          chunks.push(value);
-      }
-    } finally {
-      try {
-        reader.releaseLock();
-      } catch {}
-    }
-    const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
-    const data = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const c of chunks) {
-      data.set(c, offset);
-      offset += c.length;
-    }
-    const lastModified = Date.now();
-    const mimeType = options?.contentType ?? this.detectMimeType(normalized);
-    this.files.set(normalized, {
-      contents: data,
-      visibility: "private",
-      mimeType,
-      lastModified
-    });
-    return { path: normalized, size: data.length, contentType: mimeType, lastModified };
-  }
-  async readToString(path) {
-    const data = await this.read(path);
-    return new TextDecoder().decode(data);
-  }
-  async readToBuffer(path) {
-    const data = await this.read(path);
-    return Buffer3.from(data);
-  }
-  async readToUint8Array(path) {
-    const data = await this.read(path);
-    return data;
-  }
-  async deleteFile(path) {
-    const normalized = this.normalizePath(path);
-    if (!this.files.has(normalized)) {
-      throw new Error(`File not found: ${path}`);
-    }
-    this.files.delete(normalized);
-  }
-  async deleteDirectory(path) {
-    const normalized = this.normalizePath(path);
-    const prefix = normalized ? `${normalized}/` : "";
-    for (const filePath of this.files.keys()) {
-      if (filePath === normalized || filePath.startsWith(prefix)) {
-        this.files.delete(filePath);
-      }
-    }
-    for (const dir of this.directories) {
-      if (dir === normalized || dir.startsWith(prefix)) {
-        this.directories.delete(dir);
-      }
-    }
-  }
-  async createDirectory(path) {
-    const normalized = this.normalizePath(path);
-    if (!normalized)
-      return;
-    const parts = normalized.split("/").filter(Boolean);
-    let current = "";
-    for (const part of parts) {
-      current = current ? `${current}/${part}` : part;
-      this.directories.add(current);
-    }
-  }
-  async moveFile(from, to) {
-    const normalizedFrom = this.normalizePath(from);
-    const normalizedTo = this.normalizePath(to);
-    const file = this.files.get(normalizedFrom);
-    if (!file) {
-      throw new Error(`File not found: ${from}`);
-    }
-    const toDir = this.getDirectoryPath(normalizedTo);
-    if (toDir) {
-      await this.createDirectory(toDir);
-    }
-    this.files.set(normalizedTo, { ...file, lastModified: Date.now() });
-    this.files.delete(normalizedFrom);
-  }
-  async copyFile(from, to) {
-    const normalizedFrom = this.normalizePath(from);
-    const normalizedTo = this.normalizePath(to);
-    const file = this.files.get(normalizedFrom);
-    if (!file) {
-      throw new Error(`File not found: ${from}`);
-    }
-    const toDir = this.getDirectoryPath(normalizedTo);
-    if (toDir) {
-      await this.createDirectory(toDir);
-    }
-    const contentsCopy = new Uint8Array(file.contents);
-    this.files.set(normalizedTo, {
-      ...file,
-      contents: contentsCopy,
-      lastModified: Date.now()
-    });
-  }
-  async stat(path) {
-    const normalized = this.normalizePath(path);
-    const file = this.files.get(normalized);
-    if (file) {
-      return {
-        path: normalized,
-        type: "file",
-        visibility: file.visibility,
-        size: file.contents.length,
-        lastModified: file.lastModified,
-        mimeType: file.mimeType
-      };
-    }
-    if (this.directories.has(normalized) || normalized === "") {
-      return {
-        path: normalized,
-        type: "directory",
-        visibility: "private",
-        size: 0,
-        lastModified: Date.now()
-      };
-    }
-    throw new Error(`Path not found: ${path}`);
-  }
-  list(path, options = {}) {
-    return this.createAsyncIterator(path, options.deep || false);
-  }
-  async* createAsyncIterator(path, deep) {
-    const normalized = this.normalizePath(path);
-    const prefix = normalized ? `${normalized}/` : "";
-    const entries = [];
-    const seen = new Set;
-    for (const [filePath] of this.files) {
-      if (filePath.startsWith(prefix) || prefix === "") {
-        const relativePath = prefix ? filePath.slice(prefix.length) : filePath;
-        if (!deep) {
-          const parts = relativePath.split("/").filter(Boolean);
-          if (parts.length === 1) {
-            entries.push({
-              path: filePath,
-              type: "file"
-            });
-          }
-        } else {
-          entries.push({
-            path: filePath,
-            type: "file"
-          });
-        }
-      }
-    }
-    for (const dir of this.directories) {
-      if ((dir.startsWith(prefix) || prefix === "") && dir !== normalized) {
-        const relativePath = prefix ? dir.slice(prefix.length) : dir;
-        if (!deep) {
-          const parts = relativePath.split("/").filter(Boolean);
-          if (parts.length === 1 && !seen.has(dir)) {
-            entries.push({
-              path: dir,
-              type: "directory"
-            });
-            seen.add(dir);
-          }
-        } else if (!seen.has(dir)) {
-          entries.push({
-            path: dir,
-            type: "directory"
-          });
-          seen.add(dir);
-        }
-      }
-    }
-    yield* createDirectoryListing(entries);
-  }
-  async changeVisibility(path, visibility) {
-    const normalized = this.normalizePath(path);
-    const file = this.files.get(normalized);
-    if (!file) {
-      throw new Error(`File not found: ${path}`);
-    }
-    file.visibility = visibility;
-  }
-  async visibility(path) {
-    const normalized = this.normalizePath(path);
-    const file = this.files.get(normalized);
-    if (!file) {
-      throw new Error(`File not found: ${path}`);
-    }
-    return file.visibility;
-  }
-  async fileExists(path) {
-    const normalized = this.normalizePath(path);
-    return this.files.has(normalized);
-  }
-  async directoryExists(path) {
-    const normalized = this.normalizePath(path);
-    return this.directories.has(normalized) || normalized === "";
-  }
-  async publicUrl(path, options = {}) {
-    const base = (options.domain || process.env.APP_URL || "http://localhost").replace(/\/$/, "");
-    return `${base}/${this.normalizePath(path)}`;
-  }
-  async temporaryUrl(path, options) {
-    const expiry = normalizeExpiryToDate(options.expiresIn);
-    const token = Buffer3.from(`${path}:${expiry.getTime()}`).toString("base64url");
-    return `http://localhost/temp/${token}`;
-  }
-  async signedUrl(_path, _options) {
-    throw new Error("[storage/memory] signedUrl is not supported on the in-memory adapter \u2014 switch to local or s3 disk for signed URL generation.");
-  }
-  async checksum(path, options = {}) {
-    const algorithm = options.algorithm || "sha256";
-    const data = await this.readToUint8Array(path);
-    const hasher = new Bun.CryptoHasher(algorithm);
-    hasher.update(data);
-    return hasher.digest("hex");
-  }
-  async mimeType(path, _options = {}) {
-    const normalized = this.normalizePath(path);
-    const file = this.files.get(normalized);
-    if (!file) {
-      throw new Error(`File not found: ${path}`);
-    }
-    return file.mimeType;
-  }
-  detectMimeType(path) {
-    const ext = basename2(path).split(".").pop()?.toLowerCase();
-    const mimeTypes = {
-      txt: "text/plain",
-      html: "text/html",
-      css: "text/css",
-      js: "application/javascript",
-      json: "application/json",
-      xml: "application/xml",
-      pdf: "application/pdf",
-      zip: "application/zip",
-      jpg: "image/jpeg",
-      jpeg: "image/jpeg",
-      png: "image/png",
-      gif: "image/gif",
-      svg: "image/svg+xml",
-      mp4: "video/mp4",
-      mp3: "audio/mpeg",
-      wav: "audio/wav"
-    };
-    return mimeTypes[ext || ""] || "application/octet-stream";
-  }
-  async lastModified(path) {
-    const stats = await this.stat(path);
-    return stats.lastModified;
-  }
-  async fileSize(path) {
-    const stats = await this.stat(path);
-    return stats.size;
-  }
-  clear() {
-    this.files.clear();
-    this.directories.clear();
-    this.directories.add("");
-  }
-}
-function createMemoryStorage() {
-  return new InMemoryStorageAdapter;
-}
-
-// src/adapters/s3.ts
-import { Buffer as Buffer5 } from "buffer";
-import { basename as basename3 } from "path";
-
-// src/path-sanitize.ts
-class PathSanitizeError extends Error {
-  reason;
-  constructor(message, reason) {
-    super(message);
-    this.name = "PathSanitizeError";
-    this.reason = reason;
-  }
-}
-var MAX_COMPONENT_LENGTH = 255;
-var ALLOWED_DIR_CHAR = /^[A-Za-z0-9._-]+$/;
-var ALLOWED_FILENAME_CHAR = /^[A-Za-z0-9._-]+$/;
-var ALLOWED_EXTENSION = /^[a-z0-9]+$/;
-function sanitizePresignedDir(dir) {
-  if (dir === undefined || dir === "")
-    return "";
-  if (typeof dir !== "string")
-    throw new PathSanitizeError(`dir must be a string, got ${typeof dir}`, "not-string");
-  const trimmed = dir.replace(/^\/+/, "").replace(/\/+$/, "");
-  if (dir.startsWith("/"))
-    throw new PathSanitizeError(`dir must not be absolute: '${dir}'`, "absolute-path");
-  if (trimmed === "")
-    return "";
-  if (trimmed.includes("\x00"))
-    throw new PathSanitizeError(`dir contains null byte`, "null-byte");
-  if (/[\x00-\x1F\x7F]/.test(trimmed))
-    throw new PathSanitizeError(`dir contains control character`, "control-char");
-  const segments = trimmed.split("/");
-  for (const segment of segments) {
-    if (segment === "" || segment === "." || segment === "..")
-      throw new PathSanitizeError(`dir contains traversal or empty segment: '${dir}'`, "traversal");
-    if (segment.length > MAX_COMPONENT_LENGTH)
-      throw new PathSanitizeError(`dir segment exceeds ${MAX_COMPONENT_LENGTH} chars`, "too-long");
-    if (!ALLOWED_DIR_CHAR.test(segment))
-      throw new PathSanitizeError(`dir segment contains disallowed character: '${segment}'`, "invalid-char");
-  }
-  return segments.join("/");
-}
-function sanitizePresignedFilename(filename) {
-  if (typeof filename !== "string")
-    throw new PathSanitizeError(`filename must be a string, got ${typeof filename}`, "not-string");
-  if (filename === "")
-    throw new PathSanitizeError(`filename must not be empty`, "empty");
-  if (filename.length > MAX_COMPONENT_LENGTH)
-    throw new PathSanitizeError(`filename exceeds ${MAX_COMPONENT_LENGTH} chars`, "too-long");
-  if (filename.includes("\x00"))
-    throw new PathSanitizeError(`filename contains null byte`, "null-byte");
-  if (/[\x00-\x1F\x7F]/.test(filename))
-    throw new PathSanitizeError(`filename contains control character`, "control-char");
-  if (filename.includes("/") || filename.includes("\\"))
-    throw new PathSanitizeError(`filename must not contain path separators: '${filename}'`, "traversal");
-  if (filename === "." || filename === ".." || filename.startsWith("../") || filename.includes("/.."))
-    throw new PathSanitizeError(`filename contains traversal token: '${filename}'`, "traversal");
-  if (!ALLOWED_FILENAME_CHAR.test(filename))
-    throw new PathSanitizeError(`filename contains disallowed character: '${filename}'`, "invalid-char");
-  const dotIdx = filename.lastIndexOf(".");
-  if (dotIdx > 0 && dotIdx < filename.length - 1) {
-    const ext = filename.slice(dotIdx + 1).toLowerCase();
-    if (!ALLOWED_EXTENSION.test(ext))
-      throw new PathSanitizeError(`filename has invalid extension: '.${ext}'`, "invalid-extension");
-  }
-  return filename;
-}
-
-// src/s3-presigned-post.ts
-import { createHmac as createHmac3 } from "crypto";
-import { Buffer as Buffer4 } from "buffer";
-var ALGORITHM = "AWS4-HMAC-SHA256";
-var MIN_EXPIRY = 60;
-var MAX_EXPIRY = 7 * 24 * 60 * 60;
-function hmac(key, data) {
-  return createHmac3("sha256", key).update(data, "utf8").digest();
-}
-function deriveSigningKey(secretAccessKey, dateStamp, region) {
-  const kDate = hmac(`AWS4${secretAccessKey}`, dateStamp);
-  const kRegion = hmac(kDate, region);
-  const kService = hmac(kRegion, "s3");
-  const kSigning = hmac(kService, "aws4_request");
-  return kSigning;
-}
-function isoDate(now) {
-  const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, "");
-  const dateStamp = amzDate.slice(0, 8);
-  return { amzDate, dateStamp };
-}
-function signS3PresignedPost(input) {
-  const expiresIn = Math.floor(input.expiresIn);
-  if (!Number.isFinite(expiresIn) || expiresIn < MIN_EXPIRY || expiresIn > MAX_EXPIRY) {
-    throw new RangeError(`[storage/s3-post] expiresIn must be between ${MIN_EXPIRY}s and ${MAX_EXPIRY}s (got ${expiresIn}s)`);
-  }
-  if (!input.bucket)
-    throw new Error("[storage/s3-post] bucket is required");
-  if (!input.credentials?.accessKeyId || !input.credentials?.secretAccessKey) {
-    throw new Error("[storage/s3-post] credentials.accessKeyId and credentials.secretAccessKey are required");
-  }
-  const now = new Date;
-  const { amzDate, dateStamp } = isoDate(now);
-  const credentialScope = `${dateStamp}/${input.region}/s3/aws4_request`;
-  const credentialField = `${input.credentials.accessKeyId}/${credentialScope}`;
-  const expirationDate = new Date(now.getTime() + expiresIn * 1000).toISOString().replace(/\.\d{3}Z$/, "Z");
-  const conditions = [];
-  conditions.push({ bucket: input.bucket });
-  if (typeof input.key === "string") {
-    conditions.push({ key: input.key });
-  } else {
-    conditions.push(["starts-with", "$key", input.key.startsWith]);
-  }
-  const acl = input.acl ?? "private";
-  conditions.push({ acl });
-  if (typeof input.contentType === "string") {
-    conditions.push({ "Content-Type": input.contentType });
-  } else {
-    conditions.push(["starts-with", "$Content-Type", input.contentType.startsWith]);
-  }
-  if (input.contentLengthRange) {
-    if (!Number.isFinite(input.contentLengthRange.min) || input.contentLengthRange.min < 0 || !Number.isFinite(input.contentLengthRange.max) || input.contentLengthRange.max < input.contentLengthRange.min) {
-      throw new RangeError("[storage/s3-post] contentLengthRange must satisfy 0 <= min <= max");
-    }
-    conditions.push(["content-length-range", input.contentLengthRange.min, input.contentLengthRange.max]);
-  }
-  if (input.fields) {
-    for (const [k, v] of Object.entries(input.fields)) {
-      conditions.push({ [k]: v });
-    }
-  }
-  conditions.push({ "x-amz-credential": credentialField });
-  conditions.push({ "x-amz-algorithm": ALGORITHM });
-  conditions.push({ "x-amz-date": amzDate });
-  if (input.credentials.sessionToken) {
-    conditions.push({ "x-amz-security-token": input.credentials.sessionToken });
-  }
-  const policy = {
-    expiration: expirationDate,
-    conditions
-  };
-  const policyBase64 = Buffer4.from(JSON.stringify(policy), "utf8").toString("base64");
-  const signingKey = deriveSigningKey(input.credentials.secretAccessKey, dateStamp, input.region);
-  const signature = createHmac3("sha256", signingKey).update(policyBase64, "utf8").digest("hex");
-  const fields = {
-    key: typeof input.key === "string" ? input.key : `${input.key.startsWith}\${filename}`,
-    acl,
-    "Content-Type": typeof input.contentType === "string" ? input.contentType : input.contentType.startsWith,
-    "x-amz-credential": credentialField,
-    "x-amz-algorithm": ALGORITHM,
-    "x-amz-date": amzDate,
-    policy: policyBase64,
-    "x-amz-signature": signature,
-    ...input.credentials.sessionToken ? { "x-amz-security-token": input.credentials.sessionToken } : {},
-    ...input.fields ?? {}
-  };
-  return {
-    url: `https://${input.bucket}.s3.${input.region}.amazonaws.com/`,
-    fields,
-    key: typeof input.key === "string" ? input.key : input.key.startsWith
-  };
-}
-
-// src/adapters/s3.ts
-import process3 from "process";
-var S3_MIN_PART_SIZE = 5 * 1024 * 1024;
-var S3_MAX_PART_SIZE = 5 * 1024 * 1024 * 1024;
-function clampPartSize(requested) {
-  if (!Number.isFinite(requested))
-    return S3_MIN_PART_SIZE;
-  return Math.max(S3_MIN_PART_SIZE, Math.min(Math.floor(requested), S3_MAX_PART_SIZE));
-}
-
-class ChunkBuffer {
-  chunks = [];
-  total = 0;
-  constructor(_partSize) {}
-  get length() {
-    return this.total;
-  }
-  push(c) {
-    this.chunks.push(c);
-    this.total += c.length;
-  }
-  take(n) {
-    const out = new Uint8Array(n);
-    let written = 0;
-    while (written < n && this.chunks.length > 0) {
-      const head = this.chunks[0];
-      const need = n - written;
-      if (head.length <= need) {
-        out.set(head, written);
-        written += head.length;
-        this.chunks.shift();
-      } else {
-        out.set(head.subarray(0, need), written);
-        this.chunks[0] = head.subarray(need);
-        written += need;
-      }
-    }
-    this.total -= n;
-    return out;
-  }
-  flush() {
-    const out = new Uint8Array(this.total);
-    let off = 0;
-    for (const c of this.chunks) {
-      out.set(c, off);
-      off += c.length;
-    }
-    this.chunks = [];
-    this.total = 0;
-    return out;
-  }
-}
-async function isSettled(p3) {
-  const sentinel = Symbol("pending");
-  const result = await Promise.race([
-    p3.then(() => "settled", () => "settled"),
-    Promise.resolve(sentinel)
-  ]);
-  return result !== sentinel;
-}
-
-class S3StorageAdapter {
-  _client;
-  _clientPromise = null;
-  bucket;
-  prefix;
-  region;
-  credentials;
-  constructor(client, config) {
-    this._client = client;
-    this.bucket = config.bucket || "";
-    this.prefix = config.prefix || "";
-    this.region = config.region || "us-east-1";
-    this.credentials = config.credentials;
-    if (!this.bucket) {
-      throw new Error("S3 bucket name is required");
-    }
-  }
-  async getClient() {
-    if (this._client)
-      return this._client;
-    if (!this._clientPromise) {
-      this._clientPromise = import("@stacksjs/ts-cloud").then((cloud) => {
-        this._client = new cloud.S3Client(this.region);
-        return this._client;
-      });
-    }
-    return this._clientPromise;
-  }
-  resolveCredentials() {
-    if (this.credentials?.accessKeyId && this.credentials.secretAccessKey)
-      return this.credentials;
-    const accessKeyId = process3.env.AWS_ACCESS_KEY_ID;
-    const secretAccessKey = process3.env.AWS_SECRET_ACCESS_KEY;
-    const sessionToken = process3.env.AWS_SESSION_TOKEN;
-    if (!accessKeyId || !secretAccessKey) {
-      throw new Error("[storage/s3] presignedUploadPolicy requires AWS credentials \u2014 " + "pass them via S3DiskConfig.credentials or set AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY.");
-    }
-    return { accessKeyId, secretAccessKey, sessionToken };
-  }
-  prefixPath(path) {
-    if (!this.prefix)
-      return path;
-    return `${this.prefix}/${path}`.replace(/\/+/g, "/");
-  }
-  stripPrefix(path) {
-    if (!this.prefix)
-      return path;
-    const prefixWithSlash = `${this.prefix}/`;
-    return path.startsWith(prefixWithSlash) ? path.slice(prefixWithSlash.length) : path;
-  }
-  async contentsToBuffer(contents) {
-    if (typeof contents === "string") {
-      return Buffer5.from(contents, "utf8");
-    } else if (contents instanceof Buffer5) {
-      return contents;
-    } else if (contents instanceof Uint8Array) {
-      return Buffer5.from(contents);
-    } else {
-      const stream = contents;
-      if (typeof stream.getReader !== "function") {
-        throw new TypeError("[storage/s3] contents must be a web-standard ReadableStream (with .getReader()), not a Node stream.Readable. Convert via Readable.toWeb(nodeStream) before passing.");
-      }
-      const reader = contents.getReader();
-      const chunks = [];
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        if (value)
-          chunks.push(value);
-      }
-      return Buffer5.concat(chunks.map((c) => Buffer5.from(c)));
-    }
-  }
-  async write(path, contents) {
-    const key = this.prefixPath(path);
-    const body = await this.contentsToBuffer(contents);
-    const contentType = this.detectMimeType(path);
-    await (await this.getClient()).putObject({
-      bucket: this.bucket,
-      key,
-      body,
-      contentType
-    });
-    return {
-      path,
-      size: body.length,
-      contentType,
-      lastModified: Date.now()
-    };
-  }
-  async read(path) {
-    const key = this.prefixPath(path);
-    const response = await (await this.getClient()).getObject(this.bucket, key);
-    if (!response) {
-      throw new Error(`Failed to read file: ${path}`);
-    }
-    return Buffer5.from(response);
-  }
-  async getStream(path, _options) {
-    const key = this.prefixPath(path);
-    const buf = await (await this.getClient()).getObjectBuffer(this.bucket, key);
-    if (!buf)
-      throw new Error(`Failed to read file: ${path}`);
-    const bytes = new Uint8Array(buf);
-    return new ReadableStream({
-      start(controller) {
-        controller.enqueue(bytes);
-        controller.close();
-      }
-    });
-  }
-  async putStream(path, stream, options) {
-    const key = this.prefixPath(path);
-    const contentType = options?.contentType ?? this.detectMimeType(path);
-    const partSize = clampPartSize(options?.partSize ?? 5242880);
-    const concurrency = Math.max(1, Math.min(options?.concurrency ?? 4, 100));
-    const maxRetries = Math.max(0, options?.maxRetries ?? 3);
-    const signal = options?.signal;
-    const reader = stream.getReader();
-    let firstChunk = null;
-    let firstDone = false;
-    {
-      const buf = new ChunkBuffer(partSize);
-      while (!firstDone && buf.length < partSize) {
-        if (signal?.aborted) {
-          try {
-            reader.releaseLock();
-          } catch {}
-          throw new Error("aborted");
-        }
-        const { value, done } = await reader.read();
-        if (done) {
-          firstDone = true;
-          break;
-        }
-        if (value)
-          buf.push(value);
-      }
-      firstChunk = buf.flush();
-    }
-    if (firstDone) {
-      try {
-        reader.releaseLock();
-      } catch {}
-      await (await this.getClient()).putObject({
-        bucket: this.bucket,
-        key,
-        body: Buffer5.from(firstChunk),
-        contentType
-      });
-      return { path, size: firstChunk.length, contentType, lastModified: Date.now() };
-    }
-    const { UploadId: uploadId } = await (await this.getClient()).createMultipartUpload(this.bucket, key, { contentType });
-    const completedParts = [];
-    let totalBytes = 0;
-    let partNumber = 1;
-    const inflight = [];
-    const uploadOne = async (body, n) => {
-      let attempt = 0;
-      while (true) {
-        if (signal?.aborted)
-          throw new Error("aborted");
-        try {
-          const { ETag } = await (await this.getClient()).uploadPart(this.bucket, key, uploadId, n, Buffer5.from(body));
-          completedParts.push({ PartNumber: n, ETag });
-          totalBytes += body.length;
-          return;
-        } catch (err2) {
-          if (attempt >= maxRetries)
-            throw err2;
-          attempt += 1;
-        }
-      }
-    };
-    try {
-      inflight.push(uploadOne(firstChunk, partNumber++));
-      firstChunk = null;
-      const buf = new ChunkBuffer(partSize);
-      while (true) {
-        if (signal?.aborted)
-          throw new Error("aborted");
-        const { value, done } = await reader.read();
-        if (done)
-          break;
-        if (value)
-          buf.push(value);
-        while (buf.length >= partSize) {
-          const part = buf.take(partSize);
-          if (inflight.length >= concurrency) {
-            await Promise.race(inflight.map((p3, i) => p3.then(() => i)));
-            for (let i = inflight.length - 1;i >= 0; i--) {
-              if (await isSettled(inflight[i]))
-                inflight.splice(i, 1);
-            }
-          }
-          inflight.push(uploadOne(part, partNumber++));
-        }
-      }
-      try {
-        reader.releaseLock();
-      } catch {}
-      const tail = buf.flush();
-      if (tail.length > 0)
-        inflight.push(uploadOne(tail, partNumber++));
-      await Promise.all(inflight);
-      completedParts.sort((a, b) => a.PartNumber - b.PartNumber);
-      await (await this.getClient()).completeMultipartUpload(this.bucket, key, uploadId, completedParts);
-      return { path, size: totalBytes, contentType, lastModified: Date.now() };
-    } catch (err2) {
-      try {
-        await (await this.getClient()).abortMultipartUpload(this.bucket, key, uploadId);
-      } catch {}
-      throw err2;
-    }
-  }
-  async readToString(path) {
-    const key = this.prefixPath(path);
-    const response = await (await this.getClient()).getObject(this.bucket, key);
-    if (!response) {
-      throw new Error(`Failed to read file: ${path}`);
-    }
-    return response;
-  }
-  async readToBuffer(path) {
-    const contents = await this.read(path);
-    return contents;
-  }
-  async readToUint8Array(path) {
-    const buffer = await this.readToBuffer(path);
-    return new Uint8Array(buffer);
-  }
-  async deleteFile(path) {
-    const key = this.prefixPath(path);
-    await (await this.getClient()).deleteObject(this.bucket, key);
-  }
-  async deleteDirectory(path) {
-    const prefix = this.prefixPath(path);
-    const normalizedPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
-    const objects = await (await this.getClient()).listAllObjects({ bucket: this.bucket, prefix: normalizedPrefix });
-    const keys = objects.map((obj) => obj.Key).filter((k) => typeof k === "string");
-    if (keys.length === 0) {
-      return;
-    }
-    await (await this.getClient()).deleteObjects(this.bucket, keys);
-  }
-  async createDirectory(_path) {}
-  async moveFile(from, to) {
-    await this.copyFile(from, to);
-    await this.deleteFile(from);
-  }
-  async copyFile(from, to) {
-    const fromKey = this.prefixPath(from);
-    const toKey = this.prefixPath(to);
-    await (await this.getClient()).copyObject({
-      sourceBucket: this.bucket,
-      sourceKey: fromKey,
-      destinationBucket: this.bucket,
-      destinationKey: toKey
-    });
-  }
-  async stat(path) {
-    const key = this.prefixPath(path);
-    const result = await (await this.getClient()).headObject(this.bucket, key);
-    if (!result) {
-      throw new Error(`File not found: ${path}`);
-    }
-    return {
-      path,
-      type: "file",
-      visibility: "private",
-      size: result.ContentLength || 0,
-      lastModified: result.LastModified ? new Date(result.LastModified).getTime() : Date.now(),
-      mimeType: result.ContentType
-    };
-  }
-  list(path, options = {}) {
-    return this.createAsyncIterator(path, options.deep || false);
-  }
-  async* createAsyncIterator(path, deep) {
-    const prefix = this.prefixPath(path);
-    const normalizedPrefix = prefix ? `${prefix}/` : undefined;
-    if (deep) {
-      const objects = await (await this.getClient()).listAllObjects({ bucket: this.bucket, prefix: normalizedPrefix });
-      for (const obj of objects) {
-        yield {
-          path: this.stripPrefix(obj.Key),
-          type: "file"
-        };
-      }
-    } else {
-      let continuationToken;
-      do {
-        const result = await (await this.getClient()).listObjects({
-          bucket: this.bucket,
-          prefix: normalizedPrefix,
-          continuationToken
-        });
-        for (const obj of result.objects || []) {
-          yield {
-            path: this.stripPrefix(obj.Key),
-            type: "file"
-          };
-        }
-        continuationToken = result.nextContinuationToken;
-      } while (continuationToken);
-    }
-  }
-  async changeVisibility(path, vis) {
-    const key = this.prefixPath(path);
-    const acl = vis === "public" ? "public-read" : "private";
-    await (await this.getClient()).putObjectAcl(this.bucket, key, acl);
-  }
-  async visibility(path) {
-    const key = this.prefixPath(path);
-    const acl = await (await this.getClient()).getObjectAcl(this.bucket, key);
-    const grants = acl?.Grants ?? [];
-    const isPublic = grants.some((g) => g.Grantee?.URI === "http://acs.amazonaws.com/groups/global/AllUsers" && (g.Permission === "READ" || g.Permission === "FULL_CONTROL"));
-    return isPublic ? "public" : "private";
-  }
-  async fileExists(path) {
-    const key = this.prefixPath(path);
-    try {
-      const result = await (await this.getClient()).headObject(this.bucket, key);
-      return !!result;
-    } catch (error) {
-      if (!error.message?.includes("404") && !error.message?.includes("NoSuchKey") && !error.message?.includes("NotFound")) {
-        console.debug(`[s3] Unexpected error checking file existence for ${path}: ${error.message}`);
-      }
-      return false;
-    }
-  }
-  async directoryExists(path) {
-    const prefix = this.prefixPath(path);
-    const result = await (await this.getClient()).listObjects({
-      bucket: this.bucket,
-      prefix: `${prefix}/`,
-      maxKeys: 1
-    });
-    return (result.objects || []).length > 0;
-  }
-  async publicUrl(path, options = {}) {
-    const key = this.prefixPath(path);
-    const domain = options.domain || `https://${this.bucket}.s3.${this.region}.amazonaws.com`;
-    return `${domain}/${key}`;
-  }
-  async temporaryUrl(path, options) {
-    const key = this.prefixPath(path);
-    const expiresIn = Math.floor(normalizeExpiryToMilliseconds(options.expiresIn) / 1000);
-    const MIN_EXPIRY2 = 60;
-    const MAX_EXPIRY2 = 604800;
-    if (!Number.isFinite(expiresIn) || expiresIn < MIN_EXPIRY2 || expiresIn > MAX_EXPIRY2) {
-      throw new RangeError(`[storage/s3] temporaryUrl expiresIn must be between 60s and 7 days (got ${expiresIn}s)`);
-    }
-    return await (await this.getClient()).getSignedUrl({
-      bucket: this.bucket,
-      key,
-      expiresIn,
-      operation: "getObject"
-    });
-  }
-  async signedUrl(path, options) {
-    return this.temporaryUrl(path, { expiresIn: options.expiresIn });
-  }
-  async presignedUploadUrl(options) {
-    if (!options.contentType)
-      throw new Error("[storage/s3] presignedUploadUrl requires `contentType` \u2014 S3 signs against the exact header.");
-    const expiresIn = Math.floor(options.expiresIn);
-    const MIN_EXPIRY2 = 60;
-    const MAX_EXPIRY2 = 604800;
-    if (!Number.isFinite(expiresIn) || expiresIn < MIN_EXPIRY2 || expiresIn > MAX_EXPIRY2) {
-      throw new RangeError(`[storage/s3] presignedUploadUrl expiresIn must be between 60s and 7 days (got ${expiresIn}s)`);
-    }
-    const safeDir = sanitizePresignedDir(options.dir);
-    const safeFilename = options.filename !== undefined ? sanitizePresignedFilename(options.filename) : `${crypto.randomUUID().replace(/-/g, "")}${this.extensionForContentType(options.contentType)}`;
-    const path = safeDir ? `${safeDir}/${safeFilename}` : safeFilename;
-    const key = this.prefixPath(path);
-    const url = await (await this.getClient()).getSignedUrl({
-      bucket: this.bucket,
-      key,
-      expiresIn,
-      operation: "putObject"
-    });
-    return {
-      url,
-      path,
-      key,
-      contentType: options.contentType,
-      maxBytes: options.maxBytes
-    };
-  }
-  async presignedUploadPolicy(options) {
-    const credentials = this.resolveCredentials();
-    const scopedKey = typeof options.key === "string" ? this.prefixPath(options.key) : { startsWith: this.prefixPath(options.key.startsWith) };
-    return signS3PresignedPost({
-      bucket: this.bucket,
-      region: this.region,
-      credentials,
-      key: scopedKey,
-      contentType: options.contentType,
-      contentLengthRange: options.contentLengthRange,
-      acl: options.acl,
-      expiresIn: options.expiresIn,
-      fields: options.fields
-    });
-  }
-  extensionForContentType(contentType) {
-    const mime = contentType.toLowerCase().split(";")[0]?.trim() ?? "";
-    const map = {
-      "image/jpeg": ".jpg",
-      "image/jpg": ".jpg",
-      "image/png": ".png",
-      "image/webp": ".webp",
-      "image/gif": ".gif",
-      "image/avif": ".avif",
-      "image/svg+xml": ".svg",
-      "application/pdf": ".pdf",
-      "application/json": ".json",
-      "application/zip": ".zip",
-      "text/plain": ".txt",
-      "text/csv": ".csv",
-      "video/mp4": ".mp4",
-      "video/webm": ".webm",
-      "audio/mpeg": ".mp3",
-      "audio/wav": ".wav"
-    };
-    return map[mime] ?? "";
-  }
-  async checksum(path, options = {}) {
-    const algorithm = options.algorithm || "sha256";
-    const content = await this.readToUint8Array(path);
-    const hasher = new Bun.CryptoHasher(algorithm);
-    hasher.update(content);
-    return hasher.digest("hex");
-  }
-  async mimeType(path, _options = {}) {
-    const stats = await this.stat(path);
-    return stats.mimeType || this.detectMimeType(path);
-  }
-  detectMimeType(path) {
-    const ext = basename3(path).split(".").pop()?.toLowerCase();
-    const mimeTypes = {
-      txt: "text/plain",
-      html: "text/html",
-      css: "text/css",
-      js: "application/javascript",
-      json: "application/json",
-      xml: "application/xml",
-      pdf: "application/pdf",
-      zip: "application/zip",
-      jpg: "image/jpeg",
-      jpeg: "image/jpeg",
-      png: "image/png",
-      gif: "image/gif",
-      svg: "image/svg+xml",
-      mp4: "video/mp4",
-      mp3: "audio/mpeg",
-      wav: "audio/wav"
-    };
-    return mimeTypes[ext || ""] || "application/octet-stream";
-  }
-  async lastModified(path) {
-    const stats = await this.stat(path);
-    return stats.lastModified;
-  }
-  async fileSize(path) {
-    const stats = await this.stat(path);
-    return stats.size;
-  }
-}
-function createS3Storage(client, config) {
-  return new S3StorageAdapter(client, config);
-}
-
-// src/adapters/bun.ts
-import { Buffer as Buffer6 } from "buffer";
-var {file, write: bunWrite } = globalThis.Bun;
-import { chmod as chmod2, lstat as lstat2 } from "fs/promises";
-import { dirname as dirname4, join as join6, relative as relative2 } from "path";
-class BunStorageAdapter {
-  root;
-  constructor(config = {}) {
-    this.root = config.root || process.cwd();
-  }
-  resolvePath(path) {
-    const resolved = join6(this.root, path);
-    const rel = relative2(this.root, resolved);
-    if (rel.startsWith("..") || rel.startsWith("../") || rel.startsWith("..\\")) {
-      throw new Error(`Path traversal detected: '${path}' resolves outside storage root`);
-    }
-    return resolved;
-  }
-  async write(path, contents) {
-    const fullPath = this.resolvePath(path);
-    const dir = dirname4(fullPath);
-    await this.createDirectory(relative2(this.root, dir));
-    if (typeof contents === "string") {
-      await bunWrite(fullPath, contents);
-    } else if (contents instanceof Buffer6) {
-      await bunWrite(fullPath, contents);
-    } else if (contents instanceof Uint8Array) {
-      await bunWrite(fullPath, contents);
-    } else {
-      const stream = contents;
-      if (typeof stream.getReader !== "function") {
-        throw new TypeError("[storage/bun] contents must be a web-standard ReadableStream " + "(with .getReader()), not a Node stream.Readable. " + "Convert via Readable.toWeb(nodeStream) before passing.");
-      }
-      const reader = contents.getReader();
-      const chunks = [];
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        if (value)
-          chunks.push(value);
-      }
-      const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-      const result = new Uint8Array(totalLength);
-      let offset = 0;
-      for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.length;
-      }
-      await bunWrite(fullPath, result);
-    }
-    const written = file(fullPath);
-    return {
-      path,
-      size: written.size,
-      lastModified: written.lastModified
-    };
-  }
-  async read(path) {
-    const fullPath = this.resolvePath(path);
-    const bunFile = file(fullPath);
-    if (!await bunFile.exists()) {
-      throw new Error(`File not found: ${path}`);
-    }
-    return await bunFile.arrayBuffer().then((buf) => new Uint8Array(buf));
-  }
-  async getStream(path, _options) {
-    const fullPath = this.resolvePath(path);
-    const bunFile = file(fullPath);
-    if (!await bunFile.exists())
-      throw new Error(`File not found: ${path}`);
-    return bunFile.stream();
-  }
-  async putStream(path, stream, options) {
-    const fullPath = this.resolvePath(path);
-    const dir = dirname4(fullPath);
-    await this.createDirectory(relative2(this.root, dir));
-    try {
-      const body = new Response(stream);
-      const writePromise = bunWrite(fullPath, body);
-      if (options?.signal) {
-        const abortHandler = () => {};
-        options.signal.addEventListener("abort", abortHandler, { once: true });
-        try {
-          await writePromise;
-        } finally {
-          options.signal.removeEventListener("abort", abortHandler);
-        }
-      } else {
-        await writePromise;
-      }
-    } catch (err2) {
-      try {
-        await Bun.$.throws(false)`rm -f ${fullPath}`;
-      } catch {}
-      throw err2;
-    }
-    const written = file(fullPath);
-    return {
-      path,
-      size: written.size,
-      contentType: options?.contentType,
-      lastModified: written.lastModified
-    };
-  }
-  async readToString(path) {
-    const fullPath = this.resolvePath(path);
-    const bunFile = file(fullPath);
-    if (!await bunFile.exists()) {
-      throw new Error(`File not found: ${path}`);
-    }
-    return await bunFile.text();
-  }
-  async readToBuffer(path) {
-    const fullPath = this.resolvePath(path);
-    const bunFile = file(fullPath);
-    if (!await bunFile.exists()) {
-      throw new Error(`File not found: ${path}`);
-    }
-    const arrayBuffer = await bunFile.arrayBuffer();
-    return Buffer6.from(arrayBuffer);
-  }
-  async readToUint8Array(path) {
-    const fullPath = this.resolvePath(path);
-    const bunFile = file(fullPath);
-    if (!await bunFile.exists()) {
-      throw new Error(`File not found: ${path}`);
-    }
-    const arrayBuffer = await bunFile.arrayBuffer();
-    return new Uint8Array(arrayBuffer);
-  }
-  async deleteFile(path) {
-    const fullPath = this.resolvePath(path);
-    const bunFile = file(fullPath);
-    if (await bunFile.exists()) {
-      await Bun.$.throws(false)`rm ${fullPath}`;
-    }
-  }
-  async deleteDirectory(path) {
-    const fullPath = this.resolvePath(path);
-    await Bun.$.throws(false)`rm -rf ${fullPath}`;
-  }
-  async createDirectory(path) {
-    const fullPath = this.resolvePath(path);
-    await Bun.$.throws(false)`mkdir -p ${fullPath}`;
-  }
-  async moveFile(from, to) {
-    const fromPath = this.resolvePath(from);
-    const toPath = this.resolvePath(to);
-    const toDir = dirname4(toPath);
-    await this.createDirectory(relative2(this.root, toDir));
-    await Bun.$.throws(true)`mv ${fromPath} ${toPath}`;
-  }
-  async copyFile(from, to) {
-    const fromPath = this.resolvePath(from);
-    const toPath = this.resolvePath(to);
-    const toDir = dirname4(toPath);
-    await this.createDirectory(relative2(this.root, toDir));
-    await Bun.$.throws(true)`cp ${fromPath} ${toPath}`;
-  }
-  async stat(path) {
-    const fullPath = this.resolvePath(path);
-    const bunFile = file(fullPath);
-    if (!await bunFile.exists()) {
-      throw new Error(`File not found: ${path}`);
-    }
-    const stats = await Bun.file(fullPath).stat();
-    const isDir2 = stats.isDirectory();
-    return {
-      path,
-      type: isDir2 ? "directory" : "file",
-      visibility: "private",
-      size: isDir2 ? 0 : stats.size,
-      lastModified: stats.mtime?.getTime() || Date.now(),
-      mimeType: isDir2 ? undefined : bunFile.type
-    };
-  }
-  list(path, options = {}) {
-    const fullPath = this.resolvePath(path);
-    return this.createAsyncIterator(fullPath, options.deep || false);
-  }
-  async* createAsyncIterator(dirPath, deep) {
-    const entries = [];
-    try {
-      const glob2 = new Bun.Glob(deep ? "**/*" : "*");
-      for await (const entry of glob2.scan({ cwd: dirPath, onlyFiles: false })) {
-        const fullEntryPath = join6(dirPath, entry);
-        const stats = await Bun.file(fullEntryPath).stat();
-        entries.push({
-          path: relative2(this.root, fullEntryPath),
-          type: stats.isDirectory() ? "directory" : "file"
-        });
-      }
-    } catch (error) {
-      return;
-    }
-    yield* createDirectoryListing(entries);
-  }
-  async changeVisibility(path, vis) {
-    const fullPath = this.resolvePath(path);
-    const stats = await lstat2(fullPath);
-    const isDir2 = stats.isDirectory();
-    const mode = vis === "public" ? isDir2 ? 493 : 420 : isDir2 ? 448 : 384;
-    await chmod2(fullPath, mode);
-  }
-  async visibility(path) {
-    const fullPath = this.resolvePath(path);
-    const stats = await lstat2(fullPath);
-    const perms = stats.mode & 511;
-    return perms & 4 ? "public" : "private";
-  }
-  async fileExists(path) {
-    const fullPath = this.resolvePath(path);
-    const bunFile = file(fullPath);
-    return await bunFile.exists();
-  }
-  async directoryExists(path) {
-    const fullPath = this.resolvePath(path);
-    try {
-      const stats = await Bun.file(fullPath).stat();
-      return stats.isDirectory();
-    } catch {
-      return false;
-    }
-  }
-  async publicUrl(path, options = {}) {
-    const domain = options.domain || "http://localhost";
-    return `${domain}/${path}`;
-  }
-  async temporaryUrl(path, options) {
-    const expiry = normalizeExpiryToDate(options.expiresIn);
-    const token = Buffer6.from(`${path}:${expiry.getTime()}`).toString("base64url");
-    return `http://localhost/temp/${token}`;
-  }
-  async signedUrl(path, options) {
-    const token = createSignedStorageToken(path, options);
-    const baseUrl = (options.baseUrl || process.env.APP_URL || "http://localhost").replace(/\/$/, "");
-    return `${baseUrl}/__storage/${encodeURIComponent(path)}?token=${token}`;
-  }
-  async checksum(path, options = {}) {
-    const algorithm = options.algorithm || "sha256";
-    const fullPath = this.resolvePath(path);
-    const bunFile = file(fullPath);
-    if (!await bunFile.exists()) {
-      throw new Error(`File not found: ${path}`);
-    }
-    const hasher = new Bun.CryptoHasher(algorithm);
-    const arrayBuffer = await bunFile.arrayBuffer();
-    hasher.update(new Uint8Array(arrayBuffer));
-    return hasher.digest("hex");
-  }
-  async mimeType(path, _options = {}) {
-    const fullPath = this.resolvePath(path);
-    const bunFile = file(fullPath);
-    if (!await bunFile.exists()) {
-      throw new Error(`File not found: ${path}`);
-    }
-    return bunFile.type || "application/octet-stream";
-  }
-  async lastModified(path) {
-    const stats = await this.stat(path);
-    return stats.lastModified;
-  }
-  async fileSize(path) {
-    const stats = await this.stat(path);
-    return stats.size;
-  }
-}
-function createBunStorage(config = {}) {
-  return new BunStorageAdapter(config);
-}
-
-// src/adapters/scoped.ts
-var DEFAULT_SCOPE_PATTERN = /^[a-z0-9_-]+$/i;
-
-class ScopedStorageAdapter {
-  inner;
-  scope;
-  scopeWithSlash;
-  constructor(inner, options) {
-    const pattern = options.scopePattern ?? DEFAULT_SCOPE_PATTERN;
-    const cleaned = String(options.scope).replace(/^\/+|\/+$/g, "");
-    if (!cleaned)
-      throw new Error("[storage/scoped] scope is required");
-    if (!pattern.test(cleaned))
-      throw new Error(`[storage/scoped] scope '${cleaned}' contains disallowed characters`);
-    if (cleaned.includes("..") || cleaned.includes("/"))
-      throw new Error(`[storage/scoped] scope '${cleaned}' cannot contain path separators or traversal`);
-    this.inner = inner;
-    this.scope = cleaned;
-    this.scopeWithSlash = `${cleaned}/`;
-  }
-  scopePath(path) {
-    if (typeof path !== "string")
-      throw new Error("[storage/scoped] path must be a string");
-    if (path.length === 0)
-      return this.scope;
-    if (path.includes("\x00"))
-      throw new Error("[storage/scoped] path contains a null byte");
-    if (path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path))
-      throw new Error(`[storage/scoped] path '${path}' is absolute \u2014 refusing to escape scope`);
-    const segments = path.split(/[/\\]/);
-    if (segments.some((s) => s === ".."))
-      throw new Error(`[storage/scoped] path '${path}' contains a '..' segment \u2014 refusing to escape scope`);
-    return `${this.scope}/${path.replace(/^\/+/, "")}`;
-  }
-  unscopePath(path) {
-    if (path === this.scope)
-      return "";
-    if (path.startsWith(this.scopeWithSlash))
-      return path.slice(this.scopeWithSlash.length);
-    return path;
-  }
-  async write(path, contents) {
-    const result = await this.inner.write(this.scopePath(path), contents);
-    return { ...result, path: this.unscopePath(result.path) };
-  }
-  async read(path) {
-    return this.inner.read(this.scopePath(path));
-  }
-  async readToString(path) {
-    return this.inner.readToString(this.scopePath(path));
-  }
-  async readToBuffer(path) {
-    return this.inner.readToBuffer(this.scopePath(path));
-  }
-  async readToUint8Array(path) {
-    return this.inner.readToUint8Array(this.scopePath(path));
-  }
-  async deleteFile(path) {
-    return this.inner.deleteFile(this.scopePath(path));
-  }
-  async deleteDirectory(path) {
-    return this.inner.deleteDirectory(this.scopePath(path));
-  }
-  async createDirectory(path) {
-    return this.inner.createDirectory(this.scopePath(path));
-  }
-  async moveFile(from, to) {
-    return this.inner.moveFile(this.scopePath(from), this.scopePath(to));
-  }
-  async copyFile(from, to) {
-    return this.inner.copyFile(this.scopePath(from), this.scopePath(to));
-  }
-  async stat(path) {
-    const entry = await this.inner.stat(this.scopePath(path));
-    return { ...entry, path: this.unscopePath(entry.path) };
-  }
-  list(path, options) {
-    const inner = this.inner.list(this.scopePath(path), options);
-    const unscope = this.unscopePath.bind(this);
-    return async function* () {
-      for await (const entry of inner) {
-        yield { ...entry, path: unscope(entry.path) };
-      }
-    }();
-  }
-  async changeVisibility(path, visibility) {
-    return this.inner.changeVisibility(this.scopePath(path), visibility);
-  }
-  async visibility(path) {
-    return this.inner.visibility(this.scopePath(path));
-  }
-  async fileExists(path) {
-    return this.inner.fileExists(this.scopePath(path));
-  }
-  async directoryExists(path) {
-    return this.inner.directoryExists(this.scopePath(path));
-  }
-  async publicUrl(path, options) {
-    return this.inner.publicUrl(this.scopePath(path), options);
-  }
-  async temporaryUrl(path, options) {
-    return this.inner.temporaryUrl(this.scopePath(path), options);
-  }
-  async signedUrl(path, options) {
-    if (typeof this.inner.signedUrl !== "function")
-      throw new Error("[storage/scoped] wrapped adapter does not support signedUrl");
-    return this.inner.signedUrl(this.scopePath(path), options);
-  }
-  async presignedUploadUrl(options) {
-    if (typeof this.inner.presignedUploadUrl !== "function")
-      throw new Error("[storage/scoped] wrapped adapter does not support presignedUploadUrl");
-    const scopedDir = options.dir ? `${this.scope}/${options.dir.replace(/^\/+/, "")}` : this.scope;
-    const result = await this.inner.presignedUploadUrl({ ...options, dir: scopedDir });
-    return { ...result, path: this.unscopePath(result.path), key: this.unscopePath(result.key) };
-  }
-  async presignedUploadPolicy(options) {
-    if (typeof this.inner.presignedUploadPolicy !== "function")
-      throw new Error("[storage/scoped] wrapped adapter does not support presignedUploadPolicy");
-    const scopedKey = typeof options.key === "string" ? this.scopePath(options.key) : { startsWith: this.scopePath(options.key.startsWith) };
-    const result = await this.inner.presignedUploadPolicy({ ...options, key: scopedKey });
-    return { ...result, key: this.unscopePath(result.key) };
-  }
-  async getStream(path, options) {
-    if (typeof this.inner.getStream !== "function")
-      throw new Error("[storage/scoped] wrapped adapter does not support getStream");
-    return this.inner.getStream(this.scopePath(path), options);
-  }
-  async putStream(path, stream, options) {
-    if (typeof this.inner.putStream !== "function")
-      throw new Error("[storage/scoped] wrapped adapter does not support putStream");
-    const result = await this.inner.putStream(this.scopePath(path), stream, options);
-    return { ...result, path: this.unscopePath(result.path) };
-  }
-  async checksum(path, options) {
-    return this.inner.checksum(this.scopePath(path), options);
-  }
-  async mimeType(path, options) {
-    return this.inner.mimeType(this.scopePath(path), options);
-  }
-  async lastModified(path) {
-    return this.inner.lastModified(this.scopePath(path));
-  }
-  async fileSize(path) {
-    return this.inner.fileSize(this.scopePath(path));
-  }
-}
-function scoped(inner, options) {
-  return new ScopedStorageAdapter(inner, options);
-}
-// src/drivers/aws.ts
-var _adapterPromise = null;
-async function loadConfig() {
-  try {
-    const { filesystems } = await import("@stacksjs/config");
-    const s3Config = filesystems.s3;
-    return createS3Storage(null, {
-      bucket: s3Config?.bucket || "stacks",
-      prefix: s3Config?.prefix || "stx",
-      region: s3Config?.region || "us-east-1"
-    });
-  } catch {
-    const { env } = await import("@stacksjs/env");
-    return createS3Storage(null, {
-      bucket: env.AWS_S3_BUCKET || "stacks",
-      prefix: env.AWS_S3_PREFIX || "stx",
-      region: env.AWS_REGION || "us-east-1"
-    });
-  }
-}
-async function getAdapter() {
-  if (!_adapterPromise) {
-    _adapterPromise = loadConfig();
-  }
-  return _adapterPromise;
-}
-async function getAwsStorage() {
-  return getAdapter();
-}
-var aws = {
-  async write(path, contents) {
-    const adapter = await getAdapter();
-    await adapter.write(path, contents);
-  },
-  async deleteFile(path) {
-    const adapter = await getAdapter();
-    await adapter.deleteFile(path);
-  },
-  async createDirectory(path) {
-    const adapter = await getAdapter();
-    await adapter.createDirectory(path);
-  },
-  async moveFile(from, to) {
-    const adapter = await getAdapter();
-    await adapter.moveFile(from, to);
-  },
-  async copyFile(from, to) {
-    const adapter = await getAdapter();
-    await adapter.copyFile(from, to);
-  },
-  async stat(path) {
-    const adapter = await getAdapter();
-    return await adapter.stat(path);
-  },
-  list(path, options = { deep: false }) {
-    return async function* () {
-      const adapter = await getAdapter();
-      yield* adapter.list(path, options);
-    }();
-  },
-  async changeVisibility(path, visibility) {
-    const adapter = await getAdapter();
-    await adapter.changeVisibility(path, visibility);
-  },
-  async visibility(path) {
-    const adapter = await getAdapter();
-    return await adapter.visibility(path);
-  },
-  async fileExists(path) {
-    const adapter = await getAdapter();
-    return await adapter.fileExists(path);
-  },
-  async directoryExists(path) {
-    const adapter = await getAdapter();
-    return await adapter.directoryExists(path);
-  },
-  async publicUrl(path, options) {
-    const adapter = await getAdapter();
-    return await adapter.publicUrl(path, options);
-  },
-  async temporaryUrl(path, options) {
-    const adapter = await getAdapter();
-    return await adapter.temporaryUrl(path, options);
-  },
-  async checksum(path, options) {
-    const adapter = await getAdapter();
-    return await adapter.checksum(path, options);
-  },
-  async mimeType(path, options) {
-    const adapter = await getAdapter();
-    return await adapter.mimeType(path, options);
-  },
-  async lastModified(path) {
-    const adapter = await getAdapter();
-    return await adapter.lastModified(path);
-  },
-  async fileSize(path) {
-    const adapter = await getAdapter();
-    return await adapter.fileSize(path);
-  },
-  async read(path) {
-    const adapter = await getAdapter();
-    return await adapter.read(path);
-  },
-  async readToString(path) {
-    const adapter = await getAdapter();
-    return await adapter.readToString(path);
-  },
-  async readToBuffer(path) {
-    const adapter = await getAdapter();
-    return await adapter.readToBuffer(path);
-  },
-  async readToUint8Array(path) {
-    const adapter = await getAdapter();
-    return await adapter.readToUint8Array(path);
-  }
-};
-
-// src/drivers/local.ts
-import { resolve } from "path";
-import process4 from "process";
-var _adapterPromise2 = null;
-async function loadConfig2() {
-  try {
-    const { filesystems } = await import("@stacksjs/config");
-    const rootDirectory = resolve(filesystems.root || process4.cwd());
-    return createLocalStorage({ root: rootDirectory });
-  } catch {
-    const rootDirectory = resolve(process4.cwd());
-    return createLocalStorage({ root: rootDirectory });
-  }
-}
-async function getAdapter2() {
-  if (!_adapterPromise2) {
-    _adapterPromise2 = loadConfig2();
-  }
-  return _adapterPromise2;
-}
-async function getLocalStorage() {
-  return getAdapter2();
-}
-var local = {
-  async write(path, contents) {
-    const adapter = await getAdapter2();
-    await adapter.write(path, contents);
-  },
-  async deleteFile(path) {
-    const adapter = await getAdapter2();
-    await adapter.deleteFile(path);
-  },
-  async createDirectory(path) {
-    const adapter = await getAdapter2();
-    await adapter.createDirectory(path);
-  },
-  async moveFile(from, to) {
-    const adapter = await getAdapter2();
-    await adapter.moveFile(from, to);
-  },
-  async copyFile(from, to) {
-    const adapter = await getAdapter2();
-    await adapter.copyFile(from, to);
-  },
-  async stat(path) {
-    const adapter = await getAdapter2();
-    return await adapter.stat(path);
-  },
-  list(path, options = { deep: false }) {
-    return async function* () {
-      const adapter = await getAdapter2();
-      yield* adapter.list(path, options);
-    }();
-  },
-  async changeVisibility(path, visibility) {
-    const adapter = await getAdapter2();
-    await adapter.changeVisibility(path, visibility);
-  },
-  async visibility(path) {
-    const adapter = await getAdapter2();
-    return await adapter.visibility(path);
-  },
-  async fileExists(path) {
-    const adapter = await getAdapter2();
-    return await adapter.fileExists(path);
-  },
-  async directoryExists(path) {
-    const adapter = await getAdapter2();
-    return await adapter.directoryExists(path);
-  },
-  async publicUrl(path, options) {
-    const adapter = await getAdapter2();
-    return await adapter.publicUrl(path, options);
-  },
-  async temporaryUrl(path, options) {
-    const adapter = await getAdapter2();
-    return await adapter.temporaryUrl(path, options);
-  },
-  async checksum(path, options) {
-    const adapter = await getAdapter2();
-    return await adapter.checksum(path, options);
-  },
-  async mimeType(path, options) {
-    const adapter = await getAdapter2();
-    return await adapter.mimeType(path, options);
-  },
-  async lastModified(path) {
-    const adapter = await getAdapter2();
-    return await adapter.lastModified(path);
-  },
-  async fileSize(path) {
-    const adapter = await getAdapter2();
-    return await adapter.fileSize(path);
-  },
-  async read(path) {
-    const adapter = await getAdapter2();
-    return await adapter.read(path);
-  },
-  async readToString(path) {
-    const adapter = await getAdapter2();
-    return await adapter.readToString(path);
-  },
-  async readToBuffer(path) {
-    const adapter = await getAdapter2();
-    return await adapter.readToBuffer(path);
-  },
-  async readToUint8Array(path) {
-    const adapter = await getAdapter2();
-    return await adapter.readToUint8Array(path);
-  }
-};
-
-// src/drivers/memory.ts
-var adapter = createMemoryStorage();
-var memoryStorage = adapter;
-var memory = {
-  async write(path, contents) {
-    await adapter.write(path, contents);
-  },
-  async deleteFile(path) {
-    await adapter.deleteFile(path);
-  },
-  async createDirectory(path) {
-    await adapter.createDirectory(path);
-  },
-  async moveFile(from, to) {
-    await adapter.moveFile(from, to);
-  },
-  async copyFile(from, to) {
-    await adapter.copyFile(from, to);
-  },
-  async stat(path) {
-    return await adapter.stat(path);
-  },
-  list(path, options = { deep: false }) {
-    return adapter.list(path, options);
-  },
-  async changeVisibility(path, visibility) {
-    await adapter.changeVisibility(path, visibility);
-  },
-  async visibility(path) {
-    return await adapter.visibility(path);
-  },
-  async fileExists(path) {
-    return await adapter.fileExists(path);
-  },
-  async directoryExists(path) {
-    return await adapter.directoryExists(path);
-  },
-  async publicUrl(path, options) {
-    return await adapter.publicUrl(path, options);
-  },
-  async temporaryUrl(path, options) {
-    return await adapter.temporaryUrl(path, options);
-  },
-  async checksum(path, options) {
-    return await adapter.checksum(path, options);
-  },
-  async mimeType(path, options) {
-    return await adapter.mimeType(path, options);
-  },
-  async lastModified(path) {
-    return await adapter.lastModified(path);
-  },
-  async fileSize(path) {
-    return await adapter.fileSize(path);
-  },
-  async read(path) {
-    return await adapter.read(path);
-  },
-  async readToString(path) {
-    return await adapter.readToString(path);
-  },
-  async readToBuffer(path) {
-    return await adapter.readToBuffer(path);
-  },
-  async readToUint8Array(path) {
-    return await adapter.readToUint8Array(path);
-  }
-};
-
-// src/drivers/bun.ts
-import { resolve as resolve2 } from "path";
-import process5 from "process";
-var _adapterPromise3 = null;
-async function loadConfig3() {
-  try {
-    const { filesystems } = await import("@stacksjs/config");
-    const rootDirectory = resolve2(filesystems.root || process5.cwd());
-    return createBunStorage({ root: rootDirectory });
-  } catch {
-    const rootDirectory = resolve2(process5.cwd());
-    return createBunStorage({ root: rootDirectory });
-  }
-}
-async function getAdapter3() {
-  if (!_adapterPromise3) {
-    _adapterPromise3 = loadConfig3();
-  }
-  return _adapterPromise3;
-}
-async function getBunStorage() {
-  return getAdapter3();
-}
-var bun = {
-  async write(path, contents) {
-    const adapter2 = await getAdapter3();
-    await adapter2.write(path, contents);
-  },
-  async deleteFile(path) {
-    const adapter2 = await getAdapter3();
-    await adapter2.deleteFile(path);
-  },
-  async createDirectory(path) {
-    const adapter2 = await getAdapter3();
-    await adapter2.createDirectory(path);
-  },
-  async moveFile(from, to) {
-    const adapter2 = await getAdapter3();
-    await adapter2.moveFile(from, to);
-  },
-  async copyFile(from, to) {
-    const adapter2 = await getAdapter3();
-    await adapter2.copyFile(from, to);
-  },
-  async stat(path) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.stat(path);
-  },
-  list(path, options = { deep: false }) {
-    return async function* () {
-      const adapter2 = await getAdapter3();
-      yield* adapter2.list(path, options);
-    }();
-  },
-  async changeVisibility(path, visibility) {
-    const adapter2 = await getAdapter3();
-    await adapter2.changeVisibility(path, visibility);
-  },
-  async visibility(path) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.visibility(path);
-  },
-  async fileExists(path) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.fileExists(path);
-  },
-  async directoryExists(path) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.directoryExists(path);
-  },
-  async publicUrl(path, options) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.publicUrl(path, options);
-  },
-  async temporaryUrl(path, options) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.temporaryUrl(path, options);
-  },
-  async checksum(path, options) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.checksum(path, options);
-  },
-  async mimeType(path, options) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.mimeType(path, options);
-  },
-  async lastModified(path) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.lastModified(path);
-  },
-  async fileSize(path) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.fileSize(path);
-  },
-  async read(path) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.read(path);
-  },
-  async readToString(path) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.readToString(path);
-  },
-  async readToBuffer(path) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.readToBuffer(path);
-  },
-  async readToUint8Array(path) {
-    const adapter2 = await getAdapter3();
-    return await adapter2.readToUint8Array(path);
-  }
-};
-export {
-  zip,
-  writeTextFile,
-  writeJsonFile,
-  writeFileSync,
-  writeFile,
-  watchFile,
-  verifyUploadedMime,
-  verifySignedStorageToken,
-  uploadedFiles,
-  uploadedFile,
-  updateConfigFile,
-  unzip,
-  unarchive,
-  storage,
-  signS3PresignedPost2 as signS3PresignedPost,
-  serveFile,
-  scoped,
-  sanitizePresignedFilename2 as sanitizePresignedFilename,
-  sanitizePresignedDir2 as sanitizePresignedDir,
-  s3Disk,
-  revokeSignedStorageToken,
-  readTextFile,
-  readPackageJson,
-  readJsonFile,
-  readFileSync,
-  put,
-  parseDiskPath,
-  normalizeExpiryToMilliseconds,
-  normalizeExpiryToDate,
-  mkdirSync,
-  memoryStorage,
-  memory,
-  localDisk,
-  local,
-  isSignedStorageTokenRevoked,
-  isFolder,
-  isFile2 as isFile,
-  isDirectoryEmpty,
-  isDirectory,
-  isDir,
-  inflateSync,
-  helpers,
-  hashPaths,
-  hashPath,
-  hashFileOrDirectory,
-  hashDirectory,
-  hasFunctions,
-  hasFiles,
-  hasComponents,
-  gzipSync,
-  gunzipSync,
-  globSync,
-  glob,
-  getLocalStorage,
-  getFolders,
-  getFiles,
-  getBunStorage,
-  getAwsStorage,
-  get,
-  fsWatch,
-  fs,
-  folders,
-  files,
-  existsSync,
-  exists,
-  doesNotExist,
-  doesFolderExist,
-  doesExist,
-  detectMimeFromMagicBytes,
-  deleteGlob,
-  deleteFolder,
-  deleteFiles,
-  deleteFile,
-  deleteEmptyFolders,
-  deleteEmptyFolder,
-  del,
-  deflateSync,
-  decompress,
-  createSignedStorageToken2 as createSignedStorageToken,
-  createS3Storage,
-  createMemoryStorage,
-  createLocalStorage,
-  createFolder,
-  createDirectoryListing,
-  createBunStorage,
-  copyFolder,
-  copyFile,
-  copy,
-  configFromEnv,
-  compress,
-  clearRevokedSignedStorageTokens,
-  bun,
-  aws,
-  archive,
-  _dirname,
-  Visibility,
-  UploadedFile,
-  StorageManager,
-  Storage,
-  ScopedStorageAdapter,
-  S3StorageAdapter,
-  PathSanitizeError2 as PathSanitizeError,
-  LocalStorageAdapter,
-  InMemoryStorageAdapter,
-  BunStorageAdapter
-};