@gravito/nebula 1.0.0-alpha.6 → 1.0.0

package/README.md

@@ -13,7 +13,7 @@ bun add @gravito/nebula
 ## 🚀 Usage
 
 ```typescript
-import { PlanetCore } from 'gravito-core';
+import { PlanetCore } from '@gravito/core';
 import orbitStorage from '@gravito/nebula';
 
 const core = new PlanetCore();

package/README.zh-TW.md

@@ -11,7 +11,7 @@ bun add @gravito/nebula
 ## 快速開始
 
 ```typescript
-import { PlanetCore } from 'gravito-core'
+import { PlanetCore } from '@gravito/core'
 import orbitStorage from '@gravito/nebula'
 
 const core = new PlanetCore()

package/dist/index.cjs

@@ -1,141 +1,187 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
+"use strict";
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
+    __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  default: () => orbitStorage,
+var index_exports = {};
+__export(index_exports, {
+  LocalStorageProvider: () => LocalStorageProvider,
+  OrbitNebula: () => OrbitNebula,
   OrbitStorage: () => OrbitStorage,
-  LocalStorageProvider: () => LocalStorageProvider
+  default: () => orbitStorage
 });
-module.exports = __toCommonJS(exports_src);
-var import_promises = require("node:fs/promises");
-var import_node_path = require("node:path");
-
-class LocalStorageProvider {
+module.exports = __toCommonJS(index_exports);
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_core = require("@gravito/core");
+var LocalStorageProvider = class {
   rootDir;
   baseUrl;
+  runtime = (0, import_core.getRuntimeAdapter)();
+  /**
+   * Create a new LocalStorageProvider.
+   *
+   * @param rootDir - The root directory for storage.
+   * @param baseUrl - The base URL for accessing stored files.
+   */
   constructor(rootDir, baseUrl = "/storage") {
     this.rootDir = rootDir;
     this.baseUrl = baseUrl;
   }
+  /**
+   * Store data in a file.
+   *
+   * @param key - The storage key (path).
+   * @param data - The data to store.
+   */
   async put(key, data) {
-    const path = import_node_path.join(this.rootDir, key);
+    const path = this.resolveKeyPath(key);
     const dir = path.substring(0, path.lastIndexOf("/"));
     if (dir && dir !== this.rootDir) {
-      await import_promises.mkdir(dir, { recursive: true });
+      await (0, import_promises.mkdir)(dir, { recursive: true });
     }
-    await Bun.write(path, data);
+    await this.runtime.writeFile(path, data);
   }
+  /**
+   * Retrieve a file.
+   *
+   * @param key - The storage key.
+   * @returns A promise resolving to the file Blob or null if not found.
+   */
   async get(key) {
-    const file = Bun.file(import_node_path.join(this.rootDir, key));
-    if (!await file.exists()) {
+    const path = this.resolveKeyPath(key);
+    if (!await this.runtime.exists(path)) {
       return null;
     }
-    return file;
+    return await this.runtime.readFileAsBlob(path);
   }
+  /**
+   * Delete a file.
+   *
+   * @param key - The storage key.
+   */
   async delete(key) {
-    const fs = await import("node:fs/promises");
-    try {
-      await fs.unlink(import_node_path.join(this.rootDir, key));
-    } catch {}
+    await this.runtime.deleteFile(this.resolveKeyPath(key));
   }
+  /**
+   * Get the public URL for a file.
+   *
+   * @param key - The storage key.
+   * @returns The public URL string.
+   */
   getUrl(key) {
-    return `${this.baseUrl}/${key}`;
+    const safeKey = this.normalizeKey(key);
+    return `${this.baseUrl}/${safeKey}`;
   }
-}
-
-class OrbitStorage {
-  options;
+  normalizeKey(key) {
+    if (!key || key.includes("\0")) {
+      throw new Error("Invalid storage key.");
+    }
+    const normalized = (0, import_node_path.normalize)(key).replace(/^[/\\]+/, "");
+    if (normalized === "." || normalized === ".." || normalized.startsWith(`..${import_node_path.sep}`) || (0, import_node_path.isAbsolute)(normalized)) {
+      throw new Error("Invalid storage key.");
+    }
+    return normalized.replace(/\\/g, "/");
+  }
+  resolveKeyPath(key) {
+    const normalized = this.normalizeKey(key);
+    const root = (0, import_node_path.resolve)(this.rootDir);
+    const resolved = (0, import_node_path.resolve)(root, normalized);
+    const rootPrefix = root.endsWith(import_node_path.sep) ? root : `${root}${import_node_path.sep}`;
+    if (!resolved.startsWith(rootPrefix) && resolved !== root) {
+      throw new Error("Invalid storage key.");
+    }
+    return resolved;
+  }
+};
+var OrbitNebula = class {
   constructor(options) {
     this.options = options;
   }
+  /**
+   * Install storage service into PlanetCore.
+   *
+   * @param core - The PlanetCore instance.
+   * @throws {Error} If configuration or provider is missing.
+   */
   install(core) {
     const config = this.options || core.config.get("storage");
     if (!config) {
-      throw new Error('[OrbitStorage] Configuration is required. Please provide options or set "storage" in core config.');
+      throw new Error(
+        '[OrbitNebula] Configuration is required. Please provide options or set "storage" in core config.'
+      );
     }
     const { exposeAs = "storage" } = config;
     const logger = core.logger;
-    logger.info(`[OrbitStorage] Initializing Storage (Exposed as: ${exposeAs})`);
+    logger.info(`[OrbitNebula] Initializing Storage (Exposed as: ${exposeAs})`);
     let provider = config.provider;
     if (!provider && config.local) {
-      logger.info(`[OrbitStorage] Using LocalStorageProvider at ${config.local.root}`);
+      logger.info(`[OrbitNebula] Using LocalStorageProvider at ${config.local.root}`);
       provider = new LocalStorageProvider(config.local.root, config.local.baseUrl);
     }
     if (!provider) {
-      throw new Error("[OrbitStorage] No provider configured. Please provide a provider instance or local configuration.");
+      throw new Error(
+        "[OrbitNebula] No provider configured. Please provide a provider instance or local configuration."
+      );
     }
     const storageService = {
-      ...provider,
       put: async (key, data) => {
         const finalData = await core.hooks.applyFilters("storage:upload", data, { key });
         await provider?.put(key, finalData);
         await core.hooks.doAction("storage:uploaded", { key });
-      }
+      },
+      get: (key) => provider?.get(key),
+      delete: (key) => provider?.delete(key),
+      getUrl: (key) => provider?.getUrl(key)
     };
     core.adapter.use("*", async (c, next) => {
       c.set(exposeAs, storageService);
       await next();
-      return;
+      return void 0;
     });
     core.hooks.doAction("storage:init", storageService);
   }
-}
+};
 function orbitStorage(core, options) {
-  const orbit = new OrbitStorage(options);
+  const orbit = new OrbitNebula(options);
   orbit.install(core);
   let provider = options.provider;
   if (!provider && options.local) {
     provider = new LocalStorageProvider(options.local.root, options.local.baseUrl);
   }
   if (!provider) {
-    throw new Error("[OrbitStorage] No provider configured.");
+    throw new Error("[OrbitNebula] No provider configured.");
   }
   return {
-    ...provider,
     put: async (key, data) => {
       const finalData = await core.hooks.applyFilters("storage:upload", data, { key });
       await provider?.put(key, finalData);
       await core.hooks.doAction("storage:uploaded", { key });
-    }
+    },
+    get: (key) => provider?.get(key),
+    delete: (key) => provider?.delete(key),
+    getUrl: (key) => provider?.getUrl(key)
   };
 }
+var OrbitStorage = OrbitNebula;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalStorageProvider,
+  OrbitNebula,
+  OrbitStorage
+});

package/dist/index.d.cts

@@ -0,0 +1,96 @@
+import { PlanetCore, GravitoOrbit } from '@gravito/core';
+
+interface StorageProvider {
+    put(key: string, data: Blob | Buffer | string): Promise<void>;
+    get(key: string): Promise<Blob | null>;
+    delete(key: string): Promise<void>;
+    getUrl(key: string): string;
+}
+/**
+ * Local storage provider implementation.
+ */
+declare class LocalStorageProvider implements StorageProvider {
+    private rootDir;
+    private baseUrl;
+    private runtime;
+    /**
+     * Create a new LocalStorageProvider.
+     *
+     * @param rootDir - The root directory for storage.
+     * @param baseUrl - The base URL for accessing stored files.
+     */
+    constructor(rootDir: string, baseUrl?: string);
+    /**
+     * Store data in a file.
+     *
+     * @param key - The storage key (path).
+     * @param data - The data to store.
+     */
+    put(key: string, data: Blob | Buffer | string): Promise<void>;
+    /**
+     * Retrieve a file.
+     *
+     * @param key - The storage key.
+     * @returns A promise resolving to the file Blob or null if not found.
+     */
+    get(key: string): Promise<Blob | null>;
+    /**
+     * Delete a file.
+     *
+     * @param key - The storage key.
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Get the public URL for a file.
+     *
+     * @param key - The storage key.
+     * @returns The public URL string.
+     */
+    getUrl(key: string): string;
+    private normalizeKey;
+    private resolveKeyPath;
+}
+interface OrbitNebulaOptions {
+    provider?: StorageProvider;
+    exposeAs?: string;
+    local?: {
+        root: string;
+        baseUrl?: string;
+    };
+}
+/** @deprecated Use OrbitNebulaOptions instead */
+type OrbitStorageOptions = OrbitNebulaOptions;
+/**
+ * OrbitNebula - Storage Orbit
+ *
+ * Provides file storage functionality for Gravito applications.
+ */
+declare class OrbitNebula implements GravitoOrbit {
+    private options?;
+    constructor(options?: OrbitNebulaOptions | undefined);
+    /**
+     * Install storage service into PlanetCore.
+     *
+     * @param core - The PlanetCore instance.
+     * @throws {Error} If configuration or provider is missing.
+     */
+    install(core: PlanetCore): void;
+}
+/**
+ * Functional API for installing OrbitNebula.
+ *
+ * @param core - The PlanetCore instance.
+ * @param options - Storage options.
+ * @returns The configured storage provider wrapper.
+ * @throws {Error} If provider is not configured.
+ */
+declare function orbitStorage(core: PlanetCore, options: OrbitNebulaOptions): {
+    put: (key: string, data: Blob | Buffer | string) => Promise<void>;
+    get: (key: string) => Promise<Blob | null>;
+    delete: (key: string) => Promise<void>;
+    getUrl: (key: string) => string;
+};
+/** @deprecated Use OrbitNebula instead */
+declare const OrbitStorage: typeof OrbitNebula;
+
+export { LocalStorageProvider, OrbitNebula, type OrbitNebulaOptions, OrbitStorage, type OrbitStorageOptions, type StorageProvider, orbitStorage as default };

package/dist/index.d.ts

@@ -0,0 +1,96 @@
+import { PlanetCore, GravitoOrbit } from '@gravito/core';
+
+interface StorageProvider {
+    put(key: string, data: Blob | Buffer | string): Promise<void>;
+    get(key: string): Promise<Blob | null>;
+    delete(key: string): Promise<void>;
+    getUrl(key: string): string;
+}
+/**
+ * Local storage provider implementation.
+ */
+declare class LocalStorageProvider implements StorageProvider {
+    private rootDir;
+    private baseUrl;
+    private runtime;
+    /**
+     * Create a new LocalStorageProvider.
+     *
+     * @param rootDir - The root directory for storage.
+     * @param baseUrl - The base URL for accessing stored files.
+     */
+    constructor(rootDir: string, baseUrl?: string);
+    /**
+     * Store data in a file.
+     *
+     * @param key - The storage key (path).
+     * @param data - The data to store.
+     */
+    put(key: string, data: Blob | Buffer | string): Promise<void>;
+    /**
+     * Retrieve a file.
+     *
+     * @param key - The storage key.
+     * @returns A promise resolving to the file Blob or null if not found.
+     */
+    get(key: string): Promise<Blob | null>;
+    /**
+     * Delete a file.
+     *
+     * @param key - The storage key.
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Get the public URL for a file.
+     *
+     * @param key - The storage key.
+     * @returns The public URL string.
+     */
+    getUrl(key: string): string;
+    private normalizeKey;
+    private resolveKeyPath;
+}
+interface OrbitNebulaOptions {
+    provider?: StorageProvider;
+    exposeAs?: string;
+    local?: {
+        root: string;
+        baseUrl?: string;
+    };
+}
+/** @deprecated Use OrbitNebulaOptions instead */
+type OrbitStorageOptions = OrbitNebulaOptions;
+/**
+ * OrbitNebula - Storage Orbit
+ *
+ * Provides file storage functionality for Gravito applications.
+ */
+declare class OrbitNebula implements GravitoOrbit {
+    private options?;
+    constructor(options?: OrbitNebulaOptions | undefined);
+    /**
+     * Install storage service into PlanetCore.
+     *
+     * @param core - The PlanetCore instance.
+     * @throws {Error} If configuration or provider is missing.
+     */
+    install(core: PlanetCore): void;
+}
+/**
+ * Functional API for installing OrbitNebula.
+ *
+ * @param core - The PlanetCore instance.
+ * @param options - Storage options.
+ * @returns The configured storage provider wrapper.
+ * @throws {Error} If provider is not configured.
+ */
+declare function orbitStorage(core: PlanetCore, options: OrbitNebulaOptions): {
+    put: (key: string, data: Blob | Buffer | string) => Promise<void>;
+    get: (key: string) => Promise<Blob | null>;
+    delete: (key: string) => Promise<void>;
+    getUrl: (key: string) => string;
+};
+/** @deprecated Use OrbitNebula instead */
+declare const OrbitStorage: typeof OrbitNebula;
+
+export { LocalStorageProvider, OrbitNebula, type OrbitNebulaOptions, OrbitStorage, type OrbitStorageOptions, type StorageProvider, orbitStorage as default };

package/dist/index.js

@@ -0,0 +1,162 @@
+// src/index.ts
+import { mkdir } from "fs/promises";
+import { isAbsolute, normalize, resolve, sep } from "path";
+import {
+  getRuntimeAdapter
+} from "@gravito/core";
+var LocalStorageProvider = class {
+  rootDir;
+  baseUrl;
+  runtime = getRuntimeAdapter();
+  /**
+   * Create a new LocalStorageProvider.
+   *
+   * @param rootDir - The root directory for storage.
+   * @param baseUrl - The base URL for accessing stored files.
+   */
+  constructor(rootDir, baseUrl = "/storage") {
+    this.rootDir = rootDir;
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Store data in a file.
+   *
+   * @param key - The storage key (path).
+   * @param data - The data to store.
+   */
+  async put(key, data) {
+    const path = this.resolveKeyPath(key);
+    const dir = path.substring(0, path.lastIndexOf("/"));
+    if (dir && dir !== this.rootDir) {
+      await mkdir(dir, { recursive: true });
+    }
+    await this.runtime.writeFile(path, data);
+  }
+  /**
+   * Retrieve a file.
+   *
+   * @param key - The storage key.
+   * @returns A promise resolving to the file Blob or null if not found.
+   */
+  async get(key) {
+    const path = this.resolveKeyPath(key);
+    if (!await this.runtime.exists(path)) {
+      return null;
+    }
+    return await this.runtime.readFileAsBlob(path);
+  }
+  /**
+   * Delete a file.
+   *
+   * @param key - The storage key.
+   */
+  async delete(key) {
+    await this.runtime.deleteFile(this.resolveKeyPath(key));
+  }
+  /**
+   * Get the public URL for a file.
+   *
+   * @param key - The storage key.
+   * @returns The public URL string.
+   */
+  getUrl(key) {
+    const safeKey = this.normalizeKey(key);
+    return `${this.baseUrl}/${safeKey}`;
+  }
+  normalizeKey(key) {
+    if (!key || key.includes("\0")) {
+      throw new Error("Invalid storage key.");
+    }
+    const normalized = normalize(key).replace(/^[/\\]+/, "");
+    if (normalized === "." || normalized === ".." || normalized.startsWith(`..${sep}`) || isAbsolute(normalized)) {
+      throw new Error("Invalid storage key.");
+    }
+    return normalized.replace(/\\/g, "/");
+  }
+  resolveKeyPath(key) {
+    const normalized = this.normalizeKey(key);
+    const root = resolve(this.rootDir);
+    const resolved = resolve(root, normalized);
+    const rootPrefix = root.endsWith(sep) ? root : `${root}${sep}`;
+    if (!resolved.startsWith(rootPrefix) && resolved !== root) {
+      throw new Error("Invalid storage key.");
+    }
+    return resolved;
+  }
+};
+var OrbitNebula = class {
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Install storage service into PlanetCore.
+   *
+   * @param core - The PlanetCore instance.
+   * @throws {Error} If configuration or provider is missing.
+   */
+  install(core) {
+    const config = this.options || core.config.get("storage");
+    if (!config) {
+      throw new Error(
+        '[OrbitNebula] Configuration is required. Please provide options or set "storage" in core config.'
+      );
+    }
+    const { exposeAs = "storage" } = config;
+    const logger = core.logger;
+    logger.info(`[OrbitNebula] Initializing Storage (Exposed as: ${exposeAs})`);
+    let provider = config.provider;
+    if (!provider && config.local) {
+      logger.info(`[OrbitNebula] Using LocalStorageProvider at ${config.local.root}`);
+      provider = new LocalStorageProvider(config.local.root, config.local.baseUrl);
+    }
+    if (!provider) {
+      throw new Error(
+        "[OrbitNebula] No provider configured. Please provide a provider instance or local configuration."
+      );
+    }
+    const storageService = {
+      put: async (key, data) => {
+        const finalData = await core.hooks.applyFilters("storage:upload", data, { key });
+        await provider?.put(key, finalData);
+        await core.hooks.doAction("storage:uploaded", { key });
+      },
+      get: (key) => provider?.get(key),
+      delete: (key) => provider?.delete(key),
+      getUrl: (key) => provider?.getUrl(key)
+    };
+    core.adapter.use("*", async (c, next) => {
+      c.set(exposeAs, storageService);
+      await next();
+      return void 0;
+    });
+    core.hooks.doAction("storage:init", storageService);
+  }
+};
+function orbitStorage(core, options) {
+  const orbit = new OrbitNebula(options);
+  orbit.install(core);
+  let provider = options.provider;
+  if (!provider && options.local) {
+    provider = new LocalStorageProvider(options.local.root, options.local.baseUrl);
+  }
+  if (!provider) {
+    throw new Error("[OrbitNebula] No provider configured.");
+  }
+  return {
+    put: async (key, data) => {
+      const finalData = await core.hooks.applyFilters("storage:upload", data, { key });
+      await provider?.put(key, finalData);
+      await core.hooks.doAction("storage:uploaded", { key });
+    },
+    get: (key) => provider?.get(key),
+    delete: (key) => provider?.delete(key),
+    getUrl: (key) => provider?.getUrl(key)
+  };
+}
+var OrbitStorage = OrbitNebula;
+export {
+  LocalStorageProvider,
+  OrbitNebula,
+  OrbitStorage,
+  orbitStorage as default
+};

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@gravito/nebula",
-  "version": "1.0.0-alpha.6",
+  "version": "1.0.0",
   "publishConfig": {
     "access": "public"
   },
   "description": "Standard Storage Orbit for Galaxy Architecture",
-  "module": "./dist/index.mjs",
   "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "type": "module",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
+      "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     }
   },
@@ -24,7 +24,9 @@
   "scripts": {
     "build": "bun run build.ts",
     "test": "bun test",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "bun tsc -p tsconfig.json --noEmit --skipLibCheck",
+    "test:coverage": "bun test --coverage --coverage-threshold=80",
+    "test:ci": "bun test --coverage --coverage-threshold=80"
   },
   "keywords": [
     "gravito",
@@ -35,12 +37,13 @@
   "author": "Carl Lee <carllee0520@gmail.com>",
   "license": "MIT",
   "peerDependencies": {
-    "gravito-core": "1.0.0-beta.5"
+    "@gravito/core": "workspace:*"
   },
   "devDependencies": {
-    "gravito-core": "1.0.0-beta.5",
-    "hono": "^4.11.1",
     "bun-types": "latest",
+    "@gravito/core": "workspace:*",
+    "@gravito/photon": "workspace:*",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   },
   "homepage": "https://github.com/gravito-framework/gravito#readme",
@@ -49,4 +52,4 @@
     "url": "git+https://github.com/gravito-framework/gravito.git",
     "directory": "packages/nebula"
   }
-}
+}

package/dist/index.mjs

@@ -1,117 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/index.ts
-import { mkdir } from "node:fs/promises";
-import { join } from "node:path";
-
-class LocalStorageProvider {
-  rootDir;
-  baseUrl;
-  constructor(rootDir, baseUrl = "/storage") {
-    this.rootDir = rootDir;
-    this.baseUrl = baseUrl;
-  }
-  async put(key, data) {
-    const path = join(this.rootDir, key);
-    const dir = path.substring(0, path.lastIndexOf("/"));
-    if (dir && dir !== this.rootDir) {
-      await mkdir(dir, { recursive: true });
-    }
-    await Bun.write(path, data);
-  }
-  async get(key) {
-    const file = Bun.file(join(this.rootDir, key));
-    if (!await file.exists()) {
-      return null;
-    }
-    return file;
-  }
-  async delete(key) {
-    const fs = await import("node:fs/promises");
-    try {
-      await fs.unlink(join(this.rootDir, key));
-    } catch {}
-  }
-  getUrl(key) {
-    return `${this.baseUrl}/${key}`;
-  }
-}
-
-class OrbitStorage {
-  options;
-  constructor(options) {
-    this.options = options;
-  }
-  install(core) {
-    const config = this.options || core.config.get("storage");
-    if (!config) {
-      throw new Error('[OrbitStorage] Configuration is required. Please provide options or set "storage" in core config.');
-    }
-    const { exposeAs = "storage" } = config;
-    const logger = core.logger;
-    logger.info(`[OrbitStorage] Initializing Storage (Exposed as: ${exposeAs})`);
-    let provider = config.provider;
-    if (!provider && config.local) {
-      logger.info(`[OrbitStorage] Using LocalStorageProvider at ${config.local.root}`);
-      provider = new LocalStorageProvider(config.local.root, config.local.baseUrl);
-    }
-    if (!provider) {
-      throw new Error("[OrbitStorage] No provider configured. Please provide a provider instance or local configuration.");
-    }
-    const storageService = {
-      ...provider,
-      put: async (key, data) => {
-        const finalData = await core.hooks.applyFilters("storage:upload", data, { key });
-        await provider?.put(key, finalData);
-        await core.hooks.doAction("storage:uploaded", { key });
-      }
-    };
-    core.adapter.use("*", async (c, next) => {
-      c.set(exposeAs, storageService);
-      await next();
-      return;
-    });
-    core.hooks.doAction("storage:init", storageService);
-  }
-}
-function orbitStorage(core, options) {
-  const orbit = new OrbitStorage(options);
-  orbit.install(core);
-  let provider = options.provider;
-  if (!provider && options.local) {
-    provider = new LocalStorageProvider(options.local.root, options.local.baseUrl);
-  }
-  if (!provider) {
-    throw new Error("[OrbitStorage] No provider configured.");
-  }
-  return {
-    ...provider,
-    put: async (key, data) => {
-      const finalData = await core.hooks.applyFilters("storage:upload", data, { key });
-      await provider?.put(key, finalData);
-      await core.hooks.doAction("storage:uploaded", { key });
-    }
-  };
-}
-export {
-  orbitStorage as default,
-  OrbitStorage,
-  LocalStorageProvider
-};