v5.1.1

fix(smarts3): replace TypeScript server with Rust-powered core and IPC bridge
v5.1.0
2026-02-13 13:59:44 +00:00 · 2026-02-13 13:59:44 +00:00 · 2025-11-23 23:31:26 +00:00 · 2025-11-23 23:31:26 +00:00 · 2025-11-23 22:53:39 +00:00 · 2025-11-23 22:53:39 +00:00
34 changed files with 4965 additions and 2180 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -21,3 +21,4 @@ dist_*/
 .serena/

 #------# custom
+rust/target
--- a/.serena/project.yml
+++ b/.serena/project.yml
@@ -1,68 +0,0 @@
-# language of the project (csharp, python, rust, java, typescript, go, cpp, or ruby)
-#  * For C, use cpp
-#  * For JavaScript, use typescript
-# Special requirements:
-#  * csharp: Requires the presence of a .sln file in the project folder.
-language: typescript
-
-# whether to use the project's gitignore file to ignore files
-# Added on 2025-04-07
-ignore_all_files_in_gitignore: true
-# list of additional paths to ignore
-# same syntax as gitignore, so you can use * and **
-# Was previously called `ignored_dirs`, please update your config if you are using that.
-# Added (renamed) on 2025-04-07
-ignored_paths: []
-
-# whether the project is in read-only mode
-# If set to true, all editing tools will be disabled and attempts to use them will result in an error
-# Added on 2025-04-18
-read_only: false
-
-
-# list of tool names to exclude. We recommend not excluding any tools, see the readme for more details.
-# Below is the complete list of tools for convenience.
-# To make sure you have the latest list of tools, and to view their descriptions, 
-# execute `uv run scripts/print_tool_overview.py`.
-#
-#  * `activate_project`: Activates a project by name.
-#  * `check_onboarding_performed`: Checks whether project onboarding was already performed.
-#  * `create_text_file`: Creates/overwrites a file in the project directory.
-#  * `delete_lines`: Deletes a range of lines within a file.
-#  * `delete_memory`: Deletes a memory from Serena's project-specific memory store.
-#  * `execute_shell_command`: Executes a shell command.
-#  * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced.
-#  * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type).
-#  * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
-#  * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
-#  * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file.
-#  * `initial_instructions`: Gets the initial instructions for the current project.
-#     Should only be used in settings where the system prompt cannot be set,
-#     e.g. in clients you have no control over, like Claude Desktop.
-#  * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol.
-#  * `insert_at_line`: Inserts content at a given line in a file.
-#  * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol.
-#  * `list_dir`: Lists files and directories in the given directory (optionally with recursion).
-#  * `list_memories`: Lists memories in Serena's project-specific memory store.
-#  * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building).
-#  * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context).
-#  * `read_file`: Reads a file within the project directory.
-#  * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store.
-#  * `remove_project`: Removes a project from the Serena configuration.
-#  * `replace_lines`: Replaces a range of lines within a file with new content.
-#  * `replace_symbol_body`: Replaces the full definition of a symbol.
-#  * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen.
-#  * `search_for_pattern`: Performs a search for a pattern in the project.
-#  * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase.
-#  * `switch_modes`: Activates modes by providing a list of their names
-#  * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information.
-#  * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task.
-#  * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed.
-#  * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store.
-excluded_tools: []
-
-# initial prompt for the project. It will always be given to the LLM upon activating the project
-# (contrary to the memories, which are loaded on demand).
-initial_prompt: ""
-
-project_name: "smarts3"
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,111 @@
 # Changelog

+## 2026-02-13 - 5.1.1 - fix(smarts3)
+replace TypeScript server with Rust-powered core and IPC bridge
+
+- Major refactor: Node.js/TypeScript in-process server replaced by a Rust crate ('rusts3') with a TypeScript IPC wrapper (RustBridge).
+- Removed many TypeScript server modules (smarts3-server, filesystem-store, multipart-manager, controllers, router, context, logger, xml utils, etc.); Smarts3Server export removed — public API now proxies to the Rust binary.
+- Smarts3 now spawns and communicates with the rusts3 binary via RustBridge IPC (commands include start, stop, createBucket).
+- Build & packaging changes: build script now runs `tsrust` before `tsbuild`; added `@git.zone/tsrust` devDependency; added `dist_rust` artifacts and new cross-compile targets in npmextra.json; .gitignore updated for rust/target.
+- Dependency changes: added `@push.rocks/smartrust` (RustBridge) and simplified plugins surface; previous smartfs/smartxml usage removed from TS code and replaced by the Rust implementation + IPC.
+- Added Rust project files (rust/Cargo.toml, rust/src/*) implementing server, IPC management loop, storage, XML responses, errors, and config.
+- Documentation updated (README and hints) to describe the Rust core, supported prebuilt targets (linux_amd64, linux_arm64), IPC commands, and developer build notes.
+
+## 2025-11-23 - 5.1.0 - feat(multipart)
+Implement full multipart upload support with persistent manager, periodic cleanup, and API integration
+
+- Add IMultipartConfig to server config with defaults (expirationDays: 7, cleanupIntervalMinutes: 60) and merge into existing config flow
+- Introduce MultipartUploadManager: persistent upload metadata on disk, part upload/assembly, restore uploads on startup, listParts/listUploads, abort/cleanup functionality
+- Start and stop multipart cleanup task from Smarts3Server lifecycle (startCleanupTask on start, stopCleanupTask on stop) with configurable interval and expiration
+- ObjectController: support multipart endpoints (initiate, upload part, complete, abort) and move assembled final object into the object store on completion; set ETag headers and return proper XML responses
+- BucketController: support listing in-progress multipart uploads via ?uploads query parameter and return S3-compatible XML
+- Persist multipart state to disk and restore on initialization to survive restarts; perform automatic cleanup of expired uploads
+
+## 2025-11-23 - 5.0.2 - fix(readme)
+Clarify contribution agreement requirement in README
+
+- Updated the Issue Reporting and Security section in readme.md to make it explicit that developers must sign and comply with the contribution agreement (and complete identification) before obtaining a code.foss.global account to submit pull requests.
+
+## 2025-11-23 - 5.0.1 - fix(docs)
+Clarify README wording about S3 compatibility and AWS SDK usage
+
+- Update README wording to "Full S3 API compatibility" and clarify it works seamlessly with AWS SDK v3 and other S3 clients
+
+## 2025-11-23 - 5.0.0 - BREAKING CHANGE(core)
+Production-ready S3-compatible server: nested config, multipart uploads, CORS, structured logging, SmartFS migration and improved error handling
+
+- Breaking change: configuration format migrated from flat to nested structure (server, storage, auth, cors, logging, limits). Update existing configs accordingly.
+- Implemented full multipart upload support (initiate, upload part, complete, abort) with on-disk part management and final assembly.
+- Added CORS middleware with configurable origins, methods, headers, exposed headers, maxAge and credentials support.
+- Structured, configurable logging (levels: error|warn|info|debug; formats: text|json) and request/response logging middleware.
+- Simple static credential authentication middleware (configurable list of credentials).
+- Migrated filesystem operations to @push.rocks/smartfs (Web Streams interoperability) and removed smartbucket from production dependencies.
+- Improved S3-compatible error handling and XML responses (S3Error class and XML utilities).
+- Exposed Smarts3Server and made store/multipart managers accessible for tests and advanced usage; added helper methods like getS3Descriptor and createBucket.
+
+## 2025-11-23 - 4.0.0 - BREAKING CHANGE(Smarts3)
+Migrate Smarts3 configuration to nested server/storage objects and remove legacy flat config support
+
+- Smarts3.createAndStart() and Smarts3 constructor now accept ISmarts3Config with nested `server` and `storage` objects.
+- Removed support for the legacy flat config shape (top-level `port` and `cleanSlate`) / ILegacySmarts3Config.
+- Updated tests to use new config shape (server:{ port, silent } and storage:{ cleanSlate }).
+- mergeConfig and Smarts3Server now rely on the nested config shape; consumers must update their initialization code.
+
+## 2025-11-23 - 3.2.0 - feat(multipart)
+Add multipart upload support with MultipartUploadManager and controller integration
+
+- Introduce MultipartUploadManager (ts/classes/multipart-manager.ts) to manage multipart upload lifecycle and store parts on disk
+- Wire multipart manager into server and request context (S3Context, Smarts3Server) and initialize multipart storage on server start
+- Add multipart-related routes and handlers in ObjectController: initiate (POST ?uploads), upload part (PUT ?partNumber&uploadId), complete (POST ?uploadId), and abort (DELETE ?uploadId)
+- On complete, combine parts into final object and store via existing FilesystemStore workflow
+- Expose multipart manager on Smarts3Server for controller access
+
+## 2025-11-23 - 3.1.0 - feat(logging)
+Add structured Logger and integrate into Smarts3Server; pass full config to server
+
+- Introduce a new Logger class (ts/classes/logger.ts) providing leveled logging (error, warn, info, debug), text/json formats and an enable flag.
+- Integrate Logger into Smarts3Server: use structured logging for server lifecycle events, HTTP request/response logging and S3 errors instead of direct console usage.
+- Smarts3 now passes the full merged configuration into Smarts3Server (config.logging can control logging behavior).
+- Server start/stop messages and internal request/error logs are emitted via the Logger and respect the configured logging level/format and silent option.
+
+## 2025-11-23 - 3.0.4 - fix(smarts3)
+Use filesystem store for bucket creation and remove smartbucket runtime dependency
+
+- Switched createBucket to call the internal FilesystemStore.createBucket instead of using @push.rocks/smartbucket
+- Made Smarts3Server.store public so Smarts3 can access the filesystem store directly
+- Removed runtime import/export of @push.rocks/smartbucket from plugins and moved @push.rocks/smartbucket to devDependencies in package.json
+- Updated createBucket to return a simple { name } object after creating the bucket via the filesystem store
+
+## 2025-11-23 - 3.0.3 - fix(filesystem)
+Migrate filesystem implementation to @push.rocks/smartfs and add Web Streams handling
+
+- Replace dependency @push.rocks/smartfile with @push.rocks/smartfs and update README references
+- plugins: instantiate SmartFs with SmartFsProviderNode and export smartfs (remove direct fs export)
+- Refactor FilesystemStore to use smartfs directory/file APIs for initialize, reset, list, read, write, copy and delete
+- Implement Web Stream ↔ Node.js stream conversion for uploads/downloads (Readable.fromWeb and writer.write with Uint8Array)
+- Persist and read metadata (.metadata.json) and cached MD5 (.md5) via smartfs APIs
+- Update readme.hints and documentation to note successful migration and next steps
+
+## 2025-11-21 - 3.0.2 - fix(smarts3)
+Prepare patch release 3.0.2 — no code changes detected
+
+- No source changes in the diff
+- Bump patch version from 3.0.1 to 3.0.2 for maintenance/release bookkeeping
+
+## 2025-11-21 - 3.0.1 - fix(readme)
+Add Issue Reporting and Security section to README
+
+- Add guidance to report bugs, issues, and security vulnerabilities via community.foss.global
+- Inform developers how to sign a contribution agreement and get a code.foss.global account to submit pull requests
+
+## 2025-11-21 - 3.0.0 - BREAKING CHANGE(Smarts3)
+Remove legacy s3rver backend, simplify Smarts3 server API, and bump dependencies
+
+- Remove legacy s3rver backend: s3rver and its types were removed from dependencies and are no longer exported from plugins.
+- Simplify Smarts3 API: removed useCustomServer option; Smarts3 now always uses the built-in Smarts3Server (s3Instance is Smarts3Server) and stop() always calls Smarts3Server.stop().
+- Update README to remove legacy s3rver compatibility mention.
+- Dependency updates: bumped @push.rocks/smartbucket to ^4.3.0 and @push.rocks/smartxml to ^2.0.0 (major upgrades), removed s3rver/@types/s3rver, bumped @aws-sdk/client-s3 to ^3.937.0 and @git.zone/tstest to ^3.1.0.
+
 ## 2025-11-21 - 2.3.0 - feat(smarts3-server)
 Introduce native custom S3 server implementation (Smarts3Server) with routing, middleware, context, filesystem store, controllers and XML utilities; add SmartXml and AWS SDK test; keep optional legacy s3rver backend.

--- a/npmextra.json
+++ b/npmextra.json
@@ -1,5 +1,11 @@
 {
-  "gitzone": {
+  "@git.zone/tsrust": {
+    "targets": [
+      "linux_amd64",
+      "linux_arm64"
+    ]
+  },
+  "@git.zone/cli": {
    "projectType": "npm",
    "module": {
      "githost": "code.foss.global",
@@ -27,13 +33,19 @@
        "CI/CD Integration",
        "Developer Onboarding"
      ]
+    },
+    "release": {
+      "registries": [
+        "https://verdaccio.lossless.digital",
+        "https://registry.npmjs.org"
+      ],
+      "accessLevel": "public"
    }
  },
-  "npmci": {
-    "npmGlobalTools": [],
-    "npmAccessLevel": "public"
-  },
-  "tsdoc": {
+  "@git.zone/tsdoc": {
    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+  },
+  "@ship.zone/szci": {
+    "npmGlobalTools": []
  }
 }
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@push.rocks/smarts3",
-  "version": "2.3.0",
+  "version": "5.1.1",
  "private": false,
  "description": "A Node.js TypeScript package to create a local S3 endpoint for simulating AWS S3 operations using mapped local directories for development and testing purposes.",
  "main": "dist_ts/index.js",
@@ -10,15 +10,17 @@
  "license": "MIT",
  "scripts": {
    "test": "(tstest test/ --web --verbose --logfile --timeout 60)",
-    "build": "(tsbuild --web --allowimplicitany)",
+    "build": "(tsrust && tsbuild --web --allowimplicitany)",
    "buildDocs": "tsdoc"
  },
  "devDependencies": {
-    "@aws-sdk/client-s3": "^3.936.0",
+    "@aws-sdk/client-s3": "^3.937.0",
    "@git.zone/tsbuild": "^3.1.0",
    "@git.zone/tsbundle": "^2.5.2",
    "@git.zone/tsrun": "^2.0.0",
-    "@git.zone/tstest": "^3.0.0",
+    "@git.zone/tstest": "^3.1.0",
+    "@push.rocks/smartbucket": "^4.3.0",
+    "@git.zone/tsrust": "^1.3.0",
    "@types/node": "^22.9.0"
  },
  "browserslist": [
@@ -30,6 +32,7 @@
    "dist/**/*",
    "dist_*/**/*",
    "dist_ts/**/*",
+    "dist_rust/**/*",
    "dist_ts_web/**/*",
    "assets/**/*",
    "cli.js",
@@ -37,13 +40,9 @@
    "readme.md"
  ],
  "dependencies": {
-    "@push.rocks/smartbucket": "^3.3.10",
-    "@push.rocks/smartfile": "^11.2.7",
    "@push.rocks/smartpath": "^6.0.0",
-    "@push.rocks/smartxml": "^1.0.6",
-    "@tsclass/tsclass": "^9.3.0",
-    "@types/s3rver": "^3.7.0",
-    "s3rver": "^3.7.1"
+    "@push.rocks/smartrust": "^1.0.0",
+    "@tsclass/tsclass": "^9.3.0"
  },
  "keywords": [
    "S3 Mock Server",
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -8,31 +8,22 @@ importers:

  .:
    dependencies:
-      '@push.rocks/smartbucket':
-        specifier: ^3.3.10
-        version: 3.3.10
-      '@push.rocks/smartfile':
-        specifier: ^11.2.7
-        version: 11.2.7
+      '@push.rocks/smartfs':
+        specifier: ^1.1.0
+        version: 1.1.0
      '@push.rocks/smartpath':
        specifier: ^6.0.0
        version: 6.0.0
      '@push.rocks/smartxml':
-        specifier: ^1.0.6
-        version: 1.1.1
+        specifier: ^2.0.0
+        version: 2.0.0
      '@tsclass/tsclass':
        specifier: ^9.3.0
        version: 9.3.0
-      '@types/s3rver':
-        specifier: ^3.7.0
-        version: 3.7.4
-      s3rver:
-        specifier: ^3.7.1
-        version: 3.7.1
    devDependencies:
      '@aws-sdk/client-s3':
-        specifier: ^3.936.0
-        version: 3.936.0
+        specifier: ^3.937.0
+        version: 3.937.0
      '@git.zone/tsbuild':
        specifier: ^3.1.0
        version: 3.1.0
@@ -43,8 +34,11 @@ importers:
        specifier: ^2.0.0
        version: 2.0.0
      '@git.zone/tstest':
-        specifier: ^3.0.0
-        version: 3.0.1(socks@2.8.7)(typescript@5.9.3)
+        specifier: ^3.1.0
+        version: 3.1.0(socks@2.8.7)(typescript@5.9.3)
+      '@push.rocks/smartbucket':
+        specifier: ^4.3.0
+        version: 4.3.0
      '@types/node':
        specifier: ^22.9.0
        version: 22.19.1
@@ -89,8 +83,8 @@ packages:
  '@aws-crypto/util@5.2.0':
    resolution: {integrity: sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ==}

-  '@aws-sdk/client-s3@3.936.0':
-    resolution: {integrity: sha512-dnzZAkJDa9tdCxhqdnh37hdizJkernoFn0rufWahziOEmf0Yv9+mLeqR4qDmsAGUMuD1jFCmPR97FaCoh10mZg==}
+  '@aws-sdk/client-s3@3.937.0':
+    resolution: {integrity: sha512-ioeNe6HSc7PxjsUQY7foSHmgesxM5KwAeUtPhIHgKx99nrM+7xYCfW4FMvHypUzz7ZOvqlCdH7CEAZ8ParBvVg==}
    engines: {node: '>=18.0.0'}

  '@aws-sdk/client-sso@3.936.0':
@@ -240,8 +234,8 @@ packages:
  '@borewit/text-codec@0.1.1':
    resolution: {integrity: sha512-5L/uBxmjaCIX5h8Z+uu+kA9BQLkc/Wl06UGR5ajNRxu+/XjonB5i8JpgFMrPj3LXTCPA0pv8yxUvbUi+QthGGA==}

-  '@cloudflare/workers-types@4.20251120.0':
-    resolution: {integrity: sha512-/uy0Oleot60ZS037I2mxR9NEft6eQYdknKBnM76W91I+7BKznzXKj2MtXMfSXTLsxyP+6MluYRNPrRCQDlk8kw==}
+  '@cloudflare/workers-types@4.20251121.0':
+    resolution: {integrity: sha512-jzFg7hEGKzpEalxTCanN6lM8IdkvO/brsERp/+OyMms4Zi0nhDPUAg9dUcKU8wDuDUnzbjkplY6YRwle7Cq6gA==}

  '@colors/colors@1.6.0':
    resolution: {integrity: sha512-Ir+AOibqzrIsL6ajt3Rz3LskB7OiMVHqltZmspbW/TJuTVuyOMirVqAkjfY6JISiLHgyNqicAC8AyHHGzNd/dA==}
@@ -443,8 +437,8 @@ packages:
    resolution: {integrity: sha512-yA6zCjL+kn7xfZe6sL/m4K+zYqgkznG/pF6++i/E17iwzpG6dHmW+VZmYldHe86sW4DcLMvqM6CxM+KlgaEpKw==}
    hasBin: true

-  '@git.zone/tstest@3.0.1':
-    resolution: {integrity: sha512-YjjLLWGj8fE8yYAfMrLSDgdZ+JJOS7I6iRshIyr6THH5dnTONOA3R076zBaryRw58qgPn+s/0jno7wlhYhv0iw==}
+  '@git.zone/tstest@3.1.0':
+    resolution: {integrity: sha512-nshpkFvyIUUDvYcA/IOyqWBVEoxGm674ytIkA+XJ6DPO/hz2l3mMIjplc43d2U2eHkAZk8/ycr9GIo0xNhiLFg==}
    hasBin: true

  '@happy-dom/global-registrator@15.11.7':
@@ -503,22 +497,6 @@ packages:
  '@napi-rs/wasm-runtime@1.0.7':
    resolution: {integrity: sha512-SeDnOO0Tk7Okiq6DbXmmBODgOAb9dp9gjlphokTUxmt8U3liIP1ZsozBahH69j/RJv+Rfs6IwUKHTgQYJ/HBAw==}

-  '@oozcitak/dom@1.15.10':
-    resolution: {integrity: sha512-0JT29/LaxVgRcGKvHmSrUTEvZ8BXvZhGl2LASRUgHqDTC1M5g1pLmVv56IYNyt3bG2CUjDkc67wnyZC14pbQrQ==}
-    engines: {node: '>=8.0'}
-
-  '@oozcitak/infra@1.0.8':
-    resolution: {integrity: sha512-JRAUc9VR6IGHOL7OGF+yrvs0LO8SlqGnPAMqyzOuFZPSZSXI7Xf2O9+awQPSMXgIWGtgUf/dA6Hs6X6ySEaWTg==}
-    engines: {node: '>=6.0'}
-
-  '@oozcitak/url@1.0.4':
-    resolution: {integrity: sha512-kDcD8y+y3FCSOvnBI6HJgl00viO/nGbQoCINmQ0h98OhnGITrWR3bOGfwYCthgcrV8AnTJz8MzslTQbC3SOAmw==}
-    engines: {node: '>=8.0'}
-
-  '@oozcitak/util@8.3.8':
-    resolution: {integrity: sha512-T8TbSnGsxo6TDBJx/Sgv/BlVJL3tshxZP7Aq5R1mSnM5OcHY2dQaxLMu2+E8u3gN0MLOzdjurqN4ZRVuzQycOQ==}
-    engines: {node: '>=8.0'}
-
  '@oxc-project/types@0.98.0':
    resolution: {integrity: sha512-Vzmd6FsqVuz5HQVcRC/hrx7Ujo3WEVeQP7C2UNP5uy1hUY4SQvMB+93jxkI1KRHz9a/6cni3glPOtvteN+zpsw==}

@@ -612,6 +590,9 @@ packages:
  '@push.rocks/smartbucket@3.3.10':
    resolution: {integrity: sha512-0H2MioALspC8Aj0Q1FPCs2w4k2u9oJg7Q5yM8+1TZo7aRfrdxgM5HQ7z3apUaqC3ZEDewW6vSlttjHFHhMEC3A==}

+  '@push.rocks/smartbucket@4.3.0':
+    resolution: {integrity: sha512-4nstzEduCKou4R5ekKH6kUjDZXWfrtjA1hIQ4MJmTbtncmm2+4+ixjaFThS2nS8Aa+fHcBgOtKkBv8wTsgvK/Q==}
+
  '@push.rocks/smartbuffer@3.0.5':
    resolution: {integrity: sha512-pWYF08Mn8s/KF/9nHRk7pZPzuMjmYVQay2c5gGexdayxn1W4eCSYYhWH73vR2JBfGeGq/izbRNuUuEaIEeTIKA==}

@@ -663,6 +644,9 @@ packages:
  '@push.rocks/smartfile@11.2.7':
    resolution: {integrity: sha512-8Yp7/sAgPpWJBHohV92ogHWKzRomI5MEbSG6b5W2n18tqwfAmjMed0rQvsvGrSBlnEWCKgoOrYIIZbLO61+J0Q==}

+  '@push.rocks/smartfs@1.1.0':
+    resolution: {integrity: sha512-fg8JIjFUPPX5laRoBpTaGwhMfZ3Y8mFT4fUaW54Y4J/BfOBa/y0+rIFgvgvqcOZgkQlyZU+FIfL8Z6zezqxyTg==}
+
  '@push.rocks/smartguard@3.1.0':
    resolution: {integrity: sha512-J23q84f1O+TwFGmd4lrO9XLHUh2DaLXo9PN/9VmTWYzTkQDv5JehmifXVI0esophXcCIfbdIu6hbt7/aHlDF4A==}

@@ -783,9 +767,6 @@ packages:
  '@push.rocks/smartversion@3.0.5':
    resolution: {integrity: sha512-8MZSo1yqyaKxKq0Q5N188l4un++9GFWVbhCAX5mXJwewZHn97ujffTeL+eOQYpWFTEpUhaq1QhL4NhqObBCt1Q==}

-  '@push.rocks/smartxml@1.1.1':
-    resolution: {integrity: sha512-1toSmLE1EGK8oENh09XjV588+IdzUB3x1PCaxKjSyIsAt54bUQj3kH/yzLODF+19p07OE0KM5U1oqWpjOcFCzA==}
-
  '@push.rocks/smartxml@2.0.0':
    resolution: {integrity: sha512-1d06zYJX4Zt8s5w5qFOUg2LAEz9ykrh9d6CQPK4WAgOBIefb1xzVEWHc7yoxicc2OkzNgC3IBCEg3s6BncZKWw==}

@@ -2248,6 +2229,10 @@ packages:
    resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==}
    engines: {node: '>= 0.8'}

+  http-errors@2.0.1:
+    resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==}
+    engines: {node: '>= 0.8'}
+
  http-proxy-agent@7.0.2:
    resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
    engines: {node: '>= 14'}
@@ -2377,10 +2362,6 @@ packages:
  js-tokens@4.0.0:
    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}

-  js-yaml@3.14.1:
-    resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==}
-    hasBin: true
-
  js-yaml@3.14.2:
    resolution: {integrity: sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==}
    hasBin: true
@@ -3572,10 +3553,6 @@ packages:
      utf-8-validate:
        optional: true

-  xmlbuilder2@3.1.1:
-    resolution: {integrity: sha512-WCSfbfZnQDdLQLiMdGUQpMxxckeQ4oZNMNhLVkcekTu7xhD4tuUDyAPoY8CwXvBYE6LwBHd6QW2WZXlOWr1vCw==}
-    engines: {node: '>=12.0'}
-
  xmlhttprequest-ssl@2.1.2:
    resolution: {integrity: sha512-TEU+nJVUUnA4CYJFLvK5X9AOeH4KvDvhIfm0vV1GaQRtchnG0hgK5p8hw/xjv8cunWYCsiPCSDzObPyhEwq3KQ==}
    engines: {node: '>=0.4.0'}
@@ -3641,7 +3618,7 @@ snapshots:
      '@api.global/typedrequest': 3.1.10
      '@api.global/typedrequest-interfaces': 3.0.19
      '@api.global/typedsocket': 3.0.1
-      '@cloudflare/workers-types': 4.20251120.0
+      '@cloudflare/workers-types': 4.20251121.0
      '@design.estate/dees-comms': 1.0.27
      '@push.rocks/lik': 6.2.2
      '@push.rocks/smartchok': 1.1.1
@@ -3748,7 +3725,7 @@ snapshots:
      '@smithy/util-utf8': 2.3.0
      tslib: 2.8.1

-  '@aws-sdk/client-s3@3.936.0':
+  '@aws-sdk/client-s3@3.937.0':
    dependencies:
      '@aws-crypto/sha1-browser': 5.2.0
      '@aws-crypto/sha256-browser': 5.2.0
@@ -4192,7 +4169,7 @@ snapshots:

  '@borewit/text-codec@0.1.1': {}

-  '@cloudflare/workers-types@4.20251120.0': {}
+  '@cloudflare/workers-types@4.20251121.0': {}

  '@colors/colors@1.6.0': {}

@@ -4412,7 +4389,7 @@ snapshots:
      '@push.rocks/smartshell': 3.3.0
      tsx: 4.20.6

-  '@git.zone/tstest@3.0.1(socks@2.8.7)(typescript@5.9.3)':
+  '@git.zone/tstest@3.1.0(socks@2.8.7)(typescript@5.9.3)':
    dependencies:
      '@api.global/typedserver': 3.0.80
      '@git.zone/tsbundle': 2.5.2
@@ -4535,23 +4512,6 @@ snapshots:
      '@tybys/wasm-util': 0.10.1
    optional: true

-  '@oozcitak/dom@1.15.10':
-    dependencies:
-      '@oozcitak/infra': 1.0.8
-      '@oozcitak/url': 1.0.4
-      '@oozcitak/util': 8.3.8
-
-  '@oozcitak/infra@1.0.8':
-    dependencies:
-      '@oozcitak/util': 8.3.8
-
-  '@oozcitak/url@1.0.4':
-    dependencies:
-      '@oozcitak/infra': 1.0.8
-      '@oozcitak/util': 8.3.8
-
-  '@oozcitak/util@8.3.8': {}
-
  '@oxc-project/types@0.98.0': {}

  '@pdf-lib/standard-fonts@1.0.0':
@@ -4792,7 +4752,7 @@ snapshots:

  '@push.rocks/smartbucket@3.3.10':
    dependencies:
-      '@aws-sdk/client-s3': 3.936.0
+      '@aws-sdk/client-s3': 3.937.0
      '@push.rocks/smartmime': 2.0.4
      '@push.rocks/smartpath': 6.0.0
      '@push.rocks/smartpromise': 4.2.3
@@ -4804,6 +4764,21 @@ snapshots:
    transitivePeerDependencies:
      - aws-crt

+  '@push.rocks/smartbucket@4.3.0':
+    dependencies:
+      '@aws-sdk/client-s3': 3.937.0
+      '@push.rocks/smartmime': 2.0.4
+      '@push.rocks/smartpath': 6.0.0
+      '@push.rocks/smartpromise': 4.2.3
+      '@push.rocks/smartrx': 3.0.10
+      '@push.rocks/smartstream': 3.2.5
+      '@push.rocks/smartstring': 4.1.0
+      '@push.rocks/smartunique': 3.0.9
+      '@tsclass/tsclass': 9.3.0
+      minimatch: 10.1.1
+    transitivePeerDependencies:
+      - aws-crt
+
  '@push.rocks/smartbuffer@3.0.5':
    dependencies:
      uint8array-extras: 1.5.0
@@ -4948,6 +4923,10 @@ snapshots:
      glob: 11.1.0
      js-yaml: 4.1.1

+  '@push.rocks/smartfs@1.1.0':
+    dependencies:
+      '@push.rocks/smartpath': 6.0.0
+
  '@push.rocks/smartguard@3.1.0':
    dependencies:
      '@push.rocks/smartpromise': 4.2.3
@@ -5292,11 +5271,6 @@ snapshots:
      '@types/semver': 7.7.1
      semver: 7.7.3

-  '@push.rocks/smartxml@1.1.1':
-    dependencies:
-      fast-xml-parser: 4.5.3
-      xmlbuilder2: 3.1.1
-
  '@push.rocks/smartxml@2.0.0':
    dependencies:
      fast-xml-parser: 5.3.2
@@ -6183,7 +6157,7 @@ snapshots:
      bytes: 3.1.2
      content-type: 1.0.5
      debug: 4.4.3
-      http-errors: 2.0.0
+      http-errors: 2.0.1
      iconv-lite: 0.6.3
      on-finished: 2.4.1
      qs: 6.14.0
@@ -6641,7 +6615,7 @@ snapshots:
      etag: 1.8.1
      finalhandler: 2.1.0
      fresh: 2.0.0
-      http-errors: 2.0.0
+      http-errors: 2.0.1
      merge-descriptors: 2.0.0
      mime-types: 3.0.2
      on-finished: 2.4.1
@@ -6981,6 +6955,14 @@ snapshots:
      statuses: 2.0.1
      toidentifier: 1.0.1

+  http-errors@2.0.1:
+    dependencies:
+      depd: 2.0.0
+      inherits: 2.0.4
+      setprototypeof: 1.2.0
+      statuses: 2.0.2
+      toidentifier: 1.0.1
+
  http-proxy-agent@7.0.2:
    dependencies:
      agent-base: 7.1.4
@@ -7094,11 +7076,6 @@ snapshots:

  js-tokens@4.0.0: {}

-  js-yaml@3.14.1:
-    dependencies:
-      argparse: 1.0.10
-      esprima: 4.0.1
-
  js-yaml@3.14.2:
    dependencies:
      argparse: 1.0.10
@@ -8138,7 +8115,7 @@ snapshots:
      escape-html: 1.0.3
      etag: 1.8.1
      fresh: 2.0.0
-      http-errors: 2.0.0
+      http-errors: 2.0.1
      mime-types: 3.0.2
      ms: 2.1.3
      on-finished: 2.4.1
@@ -8596,13 +8573,6 @@ snapshots:

  ws@8.18.3: {}

-  xmlbuilder2@3.1.1:
-    dependencies:
-      '@oozcitak/dom': 1.15.10
-      '@oozcitak/infra': 1.0.8
-      '@oozcitak/util': 8.3.8
-      js-yaml: 3.14.1
-
  xmlhttprequest-ssl@2.1.2: {}

  y18n@5.0.8: {}
--- a/production-readiness.md
+++ b/production-readiness.md
@@ -0,0 +1,438 @@
+# Production-Readiness Plan for smarts3
+
+**Goal:** Make smarts3 production-ready as a MinIO alternative for use cases where:
+- Running MinIO is out of scope
+- You have a program written for S3 and want to use the local filesystem
+- You need a lightweight, zero-dependency S3-compatible server
+
+---
+
+## 🔍 Current State Analysis
+
+### ✅ What's Working
+
+- **Native S3 server** with zero framework dependencies
+- **Core S3 operations:** PUT, GET, HEAD, DELETE (objects & buckets)
+- **List buckets and objects** (V1 and V2 API)
+- **Object copy** with metadata handling
+- **Range requests** for partial downloads
+- **MD5 checksums** and ETag support
+- **Custom metadata** (x-amz-meta-*)
+- **Filesystem-backed storage** with Windows compatibility
+- **S3-compatible XML error responses**
+- **Middleware system** and routing
+- **AWS SDK v3 compatibility** (tested)
+
+### ❌ Production Gaps Identified
+
+---
+
+## 🎯 Critical Features (Required for Production)
+
+### 1. Multipart Upload Support 🚀 **HIGHEST PRIORITY**
+
+**Why:** Essential for uploading files >5MB efficiently. Without this, smarts3 can't handle real-world production workloads.
+
+**Implementation Required:**
+- `POST /:bucket/:key?uploads` - CreateMultipartUpload
+- `PUT /:bucket/:key?partNumber=X&uploadId=Y` - UploadPart
+- `POST /:bucket/:key?uploadId=X` - CompleteMultipartUpload
+- `DELETE /:bucket/:key?uploadId=X` - AbortMultipartUpload
+- `GET /:bucket/:key?uploadId=X` - ListParts
+- Multipart state management (temp storage for parts)
+- Part ETag tracking and validation
+- Automatic cleanup of abandoned uploads
+
+**Files to Create/Modify:**
+- `ts/controllers/multipart.controller.ts` (new)
+- `ts/classes/filesystem-store.ts` (add multipart methods)
+- `ts/classes/smarts3-server.ts` (add multipart routes)
+
+---
+
+### 2. Configurable Authentication 🔐
+
+**Why:** Currently hardcoded credentials ('S3RVER'/'S3RVER'). Production needs custom credentials.
+
+**Implementation Required:**
+- Support custom access keys and secrets via configuration
+- Implement AWS Signature V4 verification
+- Support multiple credential pairs (IAM-like users)
+- Optional: Disable authentication for local dev use
+
+**Configuration Example:**
+```typescript
+interface IAuthConfig {
+  enabled: boolean;
+  credentials: Array<{
+    accessKeyId: string;
+    secretAccessKey: string;
+  }>;
+  signatureVersion: 'v4' | 'none';
+}
+```
+
+**Files to Create/Modify:**
+- `ts/classes/auth-middleware.ts` (new)
+- `ts/classes/signature-validator.ts` (new)
+- `ts/classes/smarts3-server.ts` (integrate auth middleware)
+- `ts/index.ts` (add auth config options)
+
+---
+
+### 3. CORS Support 🌐
+
+**Why:** Required for browser-based uploads and modern web apps.
+
+**Implementation Required:**
+- Add CORS middleware
+- Support preflight OPTIONS requests
+- Configurable CORS origins, methods, headers
+- Per-bucket CORS configuration (optional)
+
+**Configuration Example:**
+```typescript
+interface ICorsConfig {
+  enabled: boolean;
+  allowedOrigins: string[]; // ['*'] or ['https://example.com']
+  allowedMethods: string[]; // ['GET', 'POST', 'PUT', 'DELETE']
+  allowedHeaders: string[]; // ['*'] or specific headers
+  exposedHeaders: string[]; // ['ETag', 'x-amz-*']
+  maxAge: number; // 3600 (seconds)
+  allowCredentials: boolean;
+}
+```
+
+**Files to Create/Modify:**
+- `ts/classes/cors-middleware.ts` (new)
+- `ts/classes/smarts3-server.ts` (integrate CORS middleware)
+- `ts/index.ts` (add CORS config options)
+
+---
+
+### 4. SSL/TLS Support 🔒
+
+**Why:** Production systems require encrypted connections.
+
+**Implementation Required:**
+- HTTPS server option with cert/key configuration
+- Auto-redirect HTTP to HTTPS (optional)
+- Support for self-signed certs in dev mode
+
+**Configuration Example:**
+```typescript
+interface ISslConfig {
+  enabled: boolean;
+  cert: string; // Path to certificate file or cert content
+  key: string; // Path to key file or key content
+  ca?: string; // Optional CA cert
+  redirectHttp?: boolean; // Redirect HTTP to HTTPS
+}
+```
+
+**Files to Create/Modify:**
+- `ts/classes/smarts3-server.ts` (add HTTPS server creation)
+- `ts/index.ts` (add SSL config options)
+
+---
+
+### 5. Production Configuration System ⚙️
+
+**Why:** Production needs flexible configuration, not just constructor options.
+
+**Implementation Required:**
+- Support configuration file (JSON/YAML)
+- Environment variable support
+- Configuration validation
+- Sensible production defaults
+- Example configurations for common use cases
+
+**Configuration File Example (`smarts3.config.json`):**
+```json
+{
+  "server": {
+    "port": 3000,
+    "address": "0.0.0.0",
+    "ssl": {
+      "enabled": true,
+      "cert": "./certs/server.crt",
+      "key": "./certs/server.key"
+    }
+  },
+  "storage": {
+    "directory": "./s3-data",
+    "cleanSlate": false
+  },
+  "auth": {
+    "enabled": true,
+    "credentials": [
+      {
+        "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
+        "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
+      }
+    ]
+  },
+  "cors": {
+    "enabled": true,
+    "allowedOrigins": ["*"],
+    "allowedMethods": ["GET", "POST", "PUT", "DELETE", "HEAD"],
+    "allowedHeaders": ["*"]
+  },
+  "limits": {
+    "maxObjectSize": 5368709120,
+    "maxMetadataSize": 2048,
+    "requestTimeout": 300000
+  },
+  "logging": {
+    "level": "info",
+    "format": "json",
+    "accessLog": {
+      "enabled": true,
+      "path": "./logs/access.log"
+    },
+    "errorLog": {
+      "enabled": true,
+      "path": "./logs/error.log"
+    }
+  }
+}
+```
+
+**Files to Create/Modify:**
+- `ts/classes/config-loader.ts` (new)
+- `ts/classes/config-validator.ts` (new)
+- `ts/index.ts` (use config loader)
+- Create example config files in root
+
+---
+
+### 6. Production Logging 📝
+
+**Why:** Console logs aren't suitable for production monitoring.
+
+**Implementation Required:**
+- Structured logging (JSON format option)
+- Log levels (ERROR, WARN, INFO, DEBUG)
+- File rotation support
+- Access logs (S3 standard format)
+- Integration with logging library
+
+**Files to Create/Modify:**
+- `ts/classes/logger.ts` (new - use @push.rocks/smartlog?)
+- `ts/classes/access-logger-middleware.ts` (new)
+- `ts/classes/smarts3-server.ts` (replace console.log with logger)
+- All controller files (use structured logging)
+
+---
+
+## 🔧 Important Features (Should Have)
+
+### 7. Health Check & Metrics 💊
+
+**Implementation Required:**
+- `GET /_health` endpoint (non-S3, for monitoring)
+- `GET /_metrics` endpoint (Prometheus format?)
+- Server stats (requests/sec, storage used, uptime)
+- Readiness/liveness probes for Kubernetes
+
+**Files to Create/Modify:**
+- `ts/controllers/health.controller.ts` (new)
+- `ts/classes/metrics-collector.ts` (new)
+- `ts/classes/smarts3-server.ts` (add health routes)
+
+---
+
+### 8. Batch Operations 📦
+
+**Implementation Required:**
+- `POST /:bucket?delete` - DeleteObjects (delete multiple objects in one request)
+- Essential for efficient cleanup operations
+
+**Files to Create/Modify:**
+- `ts/controllers/object.controller.ts` (add deleteObjects method)
+
+---
+
+### 9. Request Size Limits & Validation 🛡️
+
+**Implementation Required:**
+- Max object size configuration
+- Max metadata size limits
+- Request timeout configuration
+- Body size limits
+- Bucket name validation (S3 rules)
+- Key name validation
+
+**Files to Create/Modify:**
+- `ts/classes/validation-middleware.ts` (new)
+- `ts/utils/validators.ts` (new)
+- `ts/classes/smarts3-server.ts` (integrate validation middleware)
+
+---
+
+### 10. Conditional Requests 🔄
+
+**Implementation Required:**
+- If-Match / If-None-Match (ETag validation)
+- If-Modified-Since / If-Unmodified-Since
+- Required for caching and conflict prevention
+
+**Files to Create/Modify:**
+- `ts/controllers/object.controller.ts` (add conditional logic to GET/HEAD)
+
+---
+
+### 11. Graceful Shutdown 👋
+
+**Implementation Required:**
+- Drain existing connections
+- Reject new connections
+- Clean multipart cleanup on shutdown
+- SIGTERM/SIGINT handling
+
+**Files to Create/Modify:**
+- `ts/classes/smarts3-server.ts` (add graceful shutdown logic)
+- `ts/index.ts` (add signal handlers)
+
+---
+
+## 💡 Nice-to-Have Features
+
+### 12. Advanced Features
+
+- Bucket versioning support
+- Object tagging
+- Lifecycle policies (auto-delete old objects)
+- Storage class simulation (STANDARD, GLACIER, etc.)
+- Server-side encryption simulation
+- Presigned URL support (for time-limited access)
+
+### 13. Performance Optimizations
+
+- Stream optimization for large files
+- Optional in-memory caching for small objects
+- Parallel upload/download support
+- Compression support (gzip)
+
+### 14. Developer Experience
+
+- Docker image for easy deployment
+- Docker Compose examples
+- Kubernetes manifests
+- CLI for server management
+- Admin API for bucket management
+
+---
+
+## 📐 Implementation Phases
+
+### Phase 1: Critical Production Features (Priority 1)
+
+**Estimated Effort:** 2-3 weeks
+
+1. ✅ Multipart uploads (biggest technical lift)
+2. ✅ Configurable authentication
+3. ✅ CORS middleware
+4. ✅ Production configuration system
+5. ✅ Production logging
+
+**Outcome:** smarts3 can handle real production workloads
+
+---
+
+### Phase 2: Reliability & Operations (Priority 2)
+
+**Estimated Effort:** 1-2 weeks
+
+6. ✅ SSL/TLS support
+7. ✅ Health checks & metrics
+8. ✅ Request validation & limits
+9. ✅ Graceful shutdown
+10. ✅ Batch operations
+
+**Outcome:** smarts3 is operationally mature
+
+---
+
+### Phase 3: S3 Compatibility (Priority 3)
+
+**Estimated Effort:** 1-2 weeks
+
+11. ✅ Conditional requests
+12. ✅ Additional S3 features as needed
+13. ✅ Comprehensive test suite
+14. ✅ Documentation updates
+
+**Outcome:** smarts3 has broad S3 API compatibility
+
+---
+
+### Phase 4: Polish (Priority 4)
+
+**Estimated Effort:** As needed
+
+15. ✅ Docker packaging
+16. ✅ Performance optimization
+17. ✅ Advanced features based on user feedback
+
+**Outcome:** smarts3 is a complete MinIO alternative
+
+---
+
+## 🤔 Open Questions
+
+1. **Authentication:** Do you want full AWS Signature V4 validation, or simpler static credential checking?
+2. **Configuration:** Prefer JSON, YAML, or .env file format?
+3. **Logging:** Do you have a preferred logging library, or shall I use @push.rocks/smartlog?
+4. **Scope:** Should we tackle all of Phase 1, or start with a subset (e.g., just multipart + auth)?
+5. **Testing:** Should we add comprehensive tests as we go, or batch them at the end?
+6. **Breaking changes:** Can I modify the constructor options interface, or must it remain backward compatible?
+
+---
+
+## 🎯 Target Use Cases
+
+**With this plan implemented, smarts3 will be a solid MinIO alternative for:**
+
+✅ **Local S3 development** - Fast, simple, no Docker required
+✅ **Testing S3 integrations** - Reliable, repeatable tests
+✅ **Microservices using S3 API** with filesystem backend
+✅ **CI/CD pipelines** - Lightweight S3 for testing
+✅ **Small-to-medium production deployments** where MinIO is overkill
+✅ **Edge computing** - S3 API for local file storage
+✅ **Embedded systems** - Minimal dependencies, small footprint
+
+---
+
+## 📊 Current vs. Production Comparison
+
+| Feature | Current | After Phase 1 | After Phase 2 | Production Ready |
+|---------|---------|---------------|---------------|------------------|
+| Basic S3 ops | ✅ | ✅ | ✅ | ✅ |
+| Multipart upload | ❌ | ✅ | ✅ | ✅ |
+| Authentication | ⚠️ (hardcoded) | ✅ | ✅ | ✅ |
+| CORS | ❌ | ✅ | ✅ | ✅ |
+| SSL/TLS | ❌ | ❌ | ✅ | ✅ |
+| Config files | ❌ | ✅ | ✅ | ✅ |
+| Production logging | ⚠️ (console) | ✅ | ✅ | ✅ |
+| Health checks | ❌ | ❌ | ✅ | ✅ |
+| Request limits | ❌ | ❌ | ✅ | ✅ |
+| Graceful shutdown | ❌ | ❌ | ✅ | ✅ |
+| Conditional requests | ❌ | ❌ | ❌ | ✅ |
+| Batch operations | ❌ | ❌ | ✅ | ✅ |
+
+---
+
+## 📝 Notes
+
+- All features should maintain backward compatibility where possible
+- Each feature should include comprehensive tests
+- Documentation (readme.md) should be updated as features are added
+- Consider adding a migration guide for users upgrading from testing to production use
+- Performance benchmarks should be established and maintained
+
+---
+
+**Last Updated:** 2025-11-23
+**Status:** Planning Phase
+**Next Step:** Get approval and prioritize implementation order
--- a/readme.hints.md
+++ b/readme.hints.md
@@ -1 +1,60 @@
+# Project Hints for smarts3

+## Current State (v6.0.0-dev)
+
+- **Rust-powered S3 server** via `@push.rocks/smartrust` IPC bridge
+- High-performance: streaming I/O, zero-copy, backpressure, range seek
+- TypeScript is thin IPC wrapper; all HTTP/storage/routing in Rust binary `rusts3`
+- Full S3 compatibility: PUT, GET, HEAD, DELETE for objects and buckets
+- Multipart upload support (streaming, no OOM)
+- Authentication (AWS v2/v4 signature key extraction)
+- CORS support
+- ListBuckets, ListObjects (v1/v2), CopyObject
+
+## Architecture
+
+### Rust Binary (`rust/src/`)
+- `main.rs` - Clap CLI, management mode entry
+- `config.rs` - Serde config structs matching TS interfaces
+- `management.rs` - IPC loop (newline-delimited JSON over stdin/stdout)
+- `server.rs` - hyper 1.x HTTP server, routing, CORS, auth, all S3 handlers
+- `storage.rs` - FileStore: filesystem-backed storage, multipart manager
+- `xml_response.rs` - S3 XML response builders
+- `s3_error.rs` - S3 error codes with HTTP status mapping
+
+### TypeScript Bridge (`ts/`)
+- `ts/index.ts` - Smarts3 class with RustBridge<TRustS3Commands>
+- `ts/plugins.ts` - path, smartpath, RustBridge, tsclass
+- `ts/paths.ts` - packageDir, bucketsDir defaults
+
+### IPC Commands
+| Command | Params | Action |
+|---------|--------|--------|
+| `start` | `{ config: ISmarts3Config }` | Init storage + HTTP server |
+| `stop` | `{}` | Graceful shutdown |
+| `createBucket` | `{ name: string }` | Create bucket directory |
+
+### Storage Layout (backward-compatible)
+- Objects: `{root}/{bucket}/{key}._S3_object`
+- Metadata: `{root}/{bucket}/{key}._S3_object.metadata.json`
+- MD5: `{root}/{bucket}/{key}._S3_object.md5`
+- Multipart: `{root}/.multipart/{upload_id}/part-{N}`
+
+## Build
+
+- `pnpm build` runs `tsrust && tsbuild --web --allowimplicitany`
+- `tsrust` compiles Rust to `dist_rust/rusts3`
+- Targets: linux_amd64, linux_arm64 (configured in npmextra.json)
+
+## Dependencies
+
+- `@push.rocks/smartrust` - RustBridge IPC bridge
+- `@push.rocks/smartpath` - Path utilities
+- `@tsclass/tsclass` - IS3Descriptor type
+- `@git.zone/tsrust` (devDep) - Rust cross-compilation
+
+## Testing
+
+- `test/test.aws-sdk.node.ts` - AWS SDK v3 compatibility (10 tests)
+- `test/test.ts` - SmartBucket integration (3 tests)
+- Run: `pnpm test` or `tstest test/test.aws-sdk.node.ts --verbose`
--- a/readme.md
+++ b/readme.md
@@ -1,434 +1,392 @@
 # @push.rocks/smarts3 🚀

-**Mock S3 made simple** - A powerful Node.js TypeScript package for creating a local S3 endpoint that simulates AWS S3 operations using mapped local directories. Perfect for development and testing!
+A high-performance, S3-compatible local server powered by a **Rust core** with a clean TypeScript API. Drop-in replacement for AWS S3 during development and testing — no cloud, no Docker, no MinIO. Just `npm install` and go.

-## 🌟 Features
+## Issue Reporting and Security

- 🏃 **Lightning-fast local S3 simulation** - No more waiting for cloud operations during development
- ⚡ **Native custom S3 server** - Built on Node.js http module with zero framework dependencies (default)
- 🔄 **Full AWS S3 API compatibility** - Drop-in replacement for AWS SDK v3 and other S3 clients
- 📂 **Local directory mapping** - Your buckets live right on your filesystem with Windows-compatible encoding
- 🧪 **Perfect for testing** - Reliable, repeatable tests without cloud dependencies
- 🎯 **TypeScript-first** - Built with TypeScript for excellent type safety and IDE support
- 🔧 **Zero configuration** - Works out of the box with sensible defaults
- 🧹 **Clean slate mode** - Start fresh on every test run
- 🔀 **Legacy compatibility** - Optional s3rver backend support for backward compatibility
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
+
+## 🌟 Why smarts3?
+
+| Feature | smarts3 | MinIO | s3rver |
+|---------|---------|-------|--------|
+| Install | `pnpm add` | Docker / binary | `npm install` |
+| Startup time | ~20ms | seconds | ~200ms |
+| Large file uploads | ✅ Streaming, zero-copy | ✅ | ❌ OOM risk |
+| Range requests | ✅ Seek-based | ✅ | ❌ Full read |
+| Language | Rust + TypeScript | Go | JavaScript |
+| Multipart uploads | ✅ Full support | ✅ | ❌ |
+| Auth | AWS v2/v4 key extraction | Full IAM | Basic |
+
+### Core Features
+
+- ⚡ **Rust-powered HTTP server** — hyper 1.x with streaming I/O, zero-copy, backpressure
+- 🔄 **Full S3 API compatibility** — works with AWS SDK v3, SmartBucket, any S3 client
+- 📂 **Filesystem-backed storage** — buckets map to directories, objects to files
+- 📤 **Streaming multipart uploads** — large files without memory pressure
+- 🎯 **Byte-range requests** — `seek()` directly to the requested byte offset
+- 🔐 **Authentication** — AWS v2/v4 signature key extraction
+- 🌐 **CORS middleware** — configurable cross-origin support
+- 📊 **Structured logging** — tracing-based, error through debug levels
+- 🧹 **Clean slate mode** — wipe storage on startup for test isolation
+- 🧪 **Test-first design** — start/stop in milliseconds, no port conflicts

 ## 📦 Installation

-Install using your favorite package manager:
-
 ```bash
-# Using npm
-npm install @push.rocks/smarts3 --save-dev
-
-# Using pnpm (recommended)
 pnpm add @push.rocks/smarts3 -D
-
-# Using yarn
-yarn add @push.rocks/smarts3 --dev
 ```

+> **Note:** The package ships with precompiled Rust binaries for `linux_amd64` and `linux_arm64`. No Rust toolchain needed on your machine.
+
 ## 🚀 Quick Start

-Get up and running in seconds:
-
 ```typescript
 import { Smarts3 } from '@push.rocks/smarts3';

-// Start your local S3 server
-const s3Server = await Smarts3.createAndStart({
-  port: 3000,
-  cleanSlate: true, // Start with empty buckets
+// Start a local S3 server
+const s3 = await Smarts3.createAndStart({
+  server: { port: 3000 },
+  storage: { cleanSlate: true },
 });

 // Create a bucket
-const bucket = await s3Server.createBucket('my-awesome-bucket');
+await s3.createBucket('my-bucket');

-// Get S3 connection details for use with AWS SDK or other S3 clients
-const s3Config = await s3Server.getS3Descriptor();
+// Get connection details for any S3 client
+const descriptor = await s3.getS3Descriptor();
+// → { endpoint: 'localhost', port: 3000, accessKey: 'S3RVER', accessSecret: 'S3RVER', useSsl: false }

-// When you're done
-await s3Server.stop();
+// When done
+await s3.stop();
 ```

-## 📖 Detailed Usage Guide
+## 📖 Configuration

-### 🏗️ Setting Up Your S3 Server
-
-The `Smarts3` class provides a simple interface for managing your local S3 server:
+All config fields are optional — sensible defaults are applied automatically.

 ```typescript
-import { Smarts3 } from '@push.rocks/smarts3';
+import { Smarts3, ISmarts3Config } from '@push.rocks/smarts3';

-// Configuration options
-const config = {
-  port: 3000, // Port to run the server on (default: 3000)
-  cleanSlate: true, // Clear all data on start (default: false)
+const config: ISmarts3Config = {
+  server: {
+    port: 3000,              // Default: 3000
+    address: '0.0.0.0',      // Default: '0.0.0.0'
+    silent: false,           // Default: false
+  },
+  storage: {
+    directory: './my-data',  // Default: .nogit/bucketsDir
+    cleanSlate: false,       // Default: false — set true to wipe on start
+  },
+  auth: {
+    enabled: false,          // Default: false
+    credentials: [{
+      accessKeyId: 'MY_KEY',
+      secretAccessKey: 'MY_SECRET',
+    }],
+  },
+  cors: {
+    enabled: false,          // Default: false
+    allowedOrigins: ['*'],
+    allowedMethods: ['GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'OPTIONS'],
+    allowedHeaders: ['*'],
+    exposedHeaders: ['ETag', 'x-amz-request-id', 'x-amz-version-id'],
+    maxAge: 86400,
+    allowCredentials: false,
+  },
+  logging: {
+    level: 'info',           // 'error' | 'warn' | 'info' | 'debug'
+    format: 'text',          // 'text' | 'json'
+    enabled: true,
+  },
+  limits: {
+    maxObjectSize: 5 * 1024 * 1024 * 1024, // 5 GB
+    maxMetadataSize: 2048,
+    requestTimeout: 300000,  // 5 minutes
+  },
+  multipart: {
+    expirationDays: 7,
+    cleanupIntervalMinutes: 60,
+  },
 };

-// Create and start in one go
-const s3Server = await Smarts3.createAndStart(config);
-
-// Or create and start separately
-const s3Server = new Smarts3(config);
-await s3Server.start();
+const s3 = await Smarts3.createAndStart(config);
 ```

-### 🪣 Working with Buckets
+### Common Configurations

-Creating and managing buckets is straightforward:
+**CI/CD testing** — silent, clean, fast:
+```typescript
+const s3 = await Smarts3.createAndStart({
+  server: { port: 9999, silent: true },
+  storage: { cleanSlate: true },
+});
+```
+
+**Auth enabled:**
+```typescript
+const s3 = await Smarts3.createAndStart({
+  auth: {
+    enabled: true,
+    credentials: [{ accessKeyId: 'test', secretAccessKey: 'test123' }],
+  },
+});
+```
+
+**CORS for local web dev:**
+```typescript
+const s3 = await Smarts3.createAndStart({
+  cors: {
+    enabled: true,
+    allowedOrigins: ['http://localhost:5173'],
+    allowCredentials: true,
+  },
+});
+```
+
+## 📤 Usage with AWS SDK v3

 ```typescript
-// Create a new bucket
-const bucket = await s3Server.createBucket('my-bucket');
+import { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';

-// The bucket is now ready to use!
-console.log(`Created bucket: ${bucket.name}`);
+const descriptor = await s3.getS3Descriptor();
+
+const client = new S3Client({
+  endpoint: `http://${descriptor.endpoint}:${descriptor.port}`,
+  region: 'us-east-1',
+  credentials: {
+    accessKeyId: descriptor.accessKey,
+    secretAccessKey: descriptor.accessSecret,
+  },
+  forcePathStyle: true,  // Required for path-style S3
+});
+
+// Upload
+await client.send(new PutObjectCommand({
+  Bucket: 'my-bucket',
+  Key: 'hello.txt',
+  Body: 'Hello, S3!',
+  ContentType: 'text/plain',
+}));
+
+// Download
+const { Body } = await client.send(new GetObjectCommand({
+  Bucket: 'my-bucket',
+  Key: 'hello.txt',
+}));
+const content = await Body.transformToString(); // "Hello, S3!"
+
+// Delete
+await client.send(new DeleteObjectCommand({
+  Bucket: 'my-bucket',
+  Key: 'hello.txt',
+}));
 ```

-### 📤 Uploading Files
-
-Use the powerful `SmartBucket` integration for file operations:
+## 🪣 Usage with SmartBucket

 ```typescript
 import { SmartBucket } from '@push.rocks/smartbucket';

-// Get connection configuration
-const s3Config = await s3Server.getS3Descriptor();
+const smartbucket = new SmartBucket(await s3.getS3Descriptor());
+const bucket = await smartbucket.createBucket('my-bucket');
+const dir = await bucket.getBaseDirectory();

-// Create a SmartBucket instance
-const smartbucket = new SmartBucket(s3Config);
+// Upload
+await dir.fastPut({ path: 'docs/readme.txt', contents: 'Hello!' });

-// Get your bucket
-const bucket = await smartbucket.getBucket('my-bucket');
+// Download
+const content = await dir.fastGet('docs/readme.txt');

-// Upload a file
-const baseDir = await bucket.getBaseDirectory();
-await baseDir.fastStore('path/to/file.txt', 'Hello, S3! 🎉');
-
-// Upload with more control
-await baseDir.fastPut({
-  path: 'documents/important.pdf',
-  contents: Buffer.from(yourPdfData),
-});
+// List
+const files = await dir.listFiles();
 ```

-### 📥 Downloading Files
+## 📤 Multipart Uploads

-Retrieve your files easily:
+For files larger than 5 MB, use multipart uploads. smarts3 handles them with **streaming I/O** — parts are written directly to disk, never buffered in memory.

 ```typescript
-// Get file contents as string
-const content = await baseDir.fastGet('path/to/file.txt');
-console.log(content); // "Hello, S3! 🎉"
+import {
+  CreateMultipartUploadCommand,
+  UploadPartCommand,
+  CompleteMultipartUploadCommand,
+} from '@aws-sdk/client-s3';

-// Get file as Buffer
-const buffer = await baseDir.fastGetBuffer('documents/important.pdf');
-```
+// 1. Initiate
+const { UploadId } = await client.send(new CreateMultipartUploadCommand({
+  Bucket: 'my-bucket',
+  Key: 'large-file.bin',
+}));

-### 📋 Listing Files
-
-Browse your bucket contents:
-
-```typescript
-// List all files in the bucket
-const files = await baseDir.listFiles();
-
-files.forEach((file) => {
-  console.log(`📄 ${file.name} (${file.size} bytes)`);
-});
-
-// List files with a specific prefix
-const docs = await baseDir.listFiles('documents/');
-```
-
-### 🗑️ Deleting Files
-
-Clean up when needed:
-
-```typescript
-// Delete a single file
-await baseDir.fastDelete('old-file.txt');
-
-// Delete multiple files
-const filesToDelete = ['temp1.txt', 'temp2.txt', 'temp3.txt'];
-for (const file of filesToDelete) {
-  await baseDir.fastDelete(file);
+// 2. Upload parts
+const parts = [];
+for (let i = 0; i < chunks.length; i++) {
+  const { ETag } = await client.send(new UploadPartCommand({
+    Bucket: 'my-bucket',
+    Key: 'large-file.bin',
+    UploadId,
+    PartNumber: i + 1,
+    Body: chunks[i],
+  }));
+  parts.push({ PartNumber: i + 1, ETag });
 }
+
+// 3. Complete
+await client.send(new CompleteMultipartUploadCommand({
+  Bucket: 'my-bucket',
+  Key: 'large-file.bin',
+  UploadId,
+  MultipartUpload: { Parts: parts },
+}));
 ```

 ## 🧪 Testing Integration

-### Using with Jest
-
 ```typescript
 import { Smarts3 } from '@push.rocks/smarts3';
+import { tap, expect } from '@git.zone/tstest/tapbundle';

-describe('S3 Operations', () => {
-  let s3Server: Smarts3;
+let s3: Smarts3;

-  beforeAll(async () => {
-    s3Server = await Smarts3.createAndStart({
-      port: 9999,
-      cleanSlate: true,
+tap.test('setup', async () => {
+  s3 = await Smarts3.createAndStart({
+    server: { port: 4567, silent: true },
+    storage: { cleanSlate: true },
  });
 });

-  afterAll(async () => {
-    await s3Server.stop();
+tap.test('should store and retrieve objects', async () => {
+  await s3.createBucket('test');
+  // ... your test logic using AWS SDK or SmartBucket
 });

-  test('should upload and retrieve a file', async () => {
-    const bucket = await s3Server.createBucket('test-bucket');
-    // Your test logic here
-  });
+tap.test('teardown', async () => {
+  await s3.stop();
 });
+
+export default tap.start();
 ```

-### Using with Mocha
-
-```typescript
-import { Smarts3 } from '@push.rocks/smarts3';
-import { expect } from 'chai';
-
-describe('S3 Operations', () => {
-  let s3Server: Smarts3;
-
-  before(async () => {
-    s3Server = await Smarts3.createAndStart({
-      port: 9999,
-      cleanSlate: true,
-    });
-  });
-
-  after(async () => {
-    await s3Server.stop();
-  });
-
-  it('should upload and retrieve a file', async () => {
-    const bucket = await s3Server.createBucket('test-bucket');
-    // Your test logic here
-  });
-});
-```
-
-## 🔌 AWS SDK Integration
-
-Use `smarts3` with the official AWS SDK:
-
-```typescript
-import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
-import { Smarts3 } from '@push.rocks/smarts3';
-
-// Start local S3
-const s3Server = await Smarts3.createAndStart({ port: 3000 });
-const config = await s3Server.getS3Descriptor();
-
-// Configure AWS SDK
-const s3Client = new S3Client({
-  endpoint: `http://${config.endpoint}:${config.port}`,
-  region: 'us-east-1',
-  credentials: {
-    accessKeyId: config.accessKey,
-    secretAccessKey: config.accessSecret,
-  },
-  forcePathStyle: true,
-});
-
-// Use AWS SDK as normal
-const command = new PutObjectCommand({
-  Bucket: 'my-bucket',
-  Key: 'test-file.txt',
-  Body: 'Hello from AWS SDK!',
-});
-
-await s3Client.send(command);
-```
-
-## 🎯 Real-World Examples
-
-### CI/CD Pipeline Testing
-
-```typescript
-// ci-test.ts
-import { Smarts3 } from '@push.rocks/smarts3';
-
-export async function setupTestEnvironment() {
-  // Start S3 server for CI tests
-  const s3 = await Smarts3.createAndStart({
-    port: process.env.S3_PORT || 3000,
-    cleanSlate: true,
-  });
-
-  // Create test buckets
-  await s3.createBucket('uploads');
-  await s3.createBucket('processed');
-  await s3.createBucket('archive');
-
-  return s3;
-}
-```
-
-### Microservice Development
-
-```typescript
-// dev-server.ts
-import { Smarts3 } from '@push.rocks/smarts3';
-import express from 'express';
-
-async function startDevelopmentServer() {
-  // Start local S3
-  const s3 = await Smarts3.createAndStart({ port: 3000 });
-  await s3.createBucket('user-uploads');
-
-  // Start your API server
-  const app = express();
-
-  app.post('/upload', async (req, res) => {
-    // Your upload logic using local S3
-  });
-
-  app.listen(8080, () => {
-    console.log('🚀 Dev server running with local S3!');
-  });
-}
-```
-
-### Data Migration Testing
-
-```typescript
-import { Smarts3 } from '@push.rocks/smarts3';
-
-async function testDataMigration() {
-  const s3 = await Smarts3.createAndStart({ cleanSlate: true });
-
-  // Create source and destination buckets
-  const sourceBucket = await s3.createBucket('legacy-data');
-  const destBucket = await s3.createBucket('new-data');
-
-  // Populate source with test data
-  const config = await s3.getS3Descriptor();
-  const smartbucket = new SmartBucket(config);
-  const source = await smartbucket.getBucket('legacy-data');
-  const sourceDir = await source.getBaseDirectory();
-
-  // Add test files
-  await sourceDir.fastStore(
-    'user-1.json',
-    JSON.stringify({ id: 1, name: 'Alice' }),
-  );
-  await sourceDir.fastStore(
-    'user-2.json',
-    JSON.stringify({ id: 2, name: 'Bob' }),
-  );
-
-  // Run your migration logic
-  await runMigration(config);
-
-  // Verify migration results
-  const dest = await smartbucket.getBucket('new-data');
-  const destDir = await dest.getBaseDirectory();
-  const migratedFiles = await destDir.listFiles();
-
-  console.log(`✅ Migrated ${migratedFiles.length} files successfully!`);
-}
-```
-
-## 🛠️ Advanced Configuration
-
-### Custom S3 Descriptor Options
-
-When integrating with different S3 clients, you can customize the connection details:
-
-```typescript
-const customDescriptor = await s3Server.getS3Descriptor({
-  endpoint: 'localhost', // Custom endpoint
-  port: 3001, // Different port
-  useSsl: false, // SSL configuration
-  // Add any additional options your S3 client needs
-});
-```
-
-### Environment-Based Configuration
-
-```typescript
-const config = {
-  port: parseInt(process.env.S3_PORT || '3000'),
-  cleanSlate: process.env.NODE_ENV === 'test',
-};
-
-const s3Server = await Smarts3.createAndStart(config);
-```
-
-## 🤝 Use Cases
-
- **🧪 Unit & Integration Testing** - Test S3 operations without AWS credentials or internet
- **🏗️ Local Development** - Develop cloud features offline with full S3 compatibility
- **📚 Teaching & Demos** - Perfect for workshops and tutorials without AWS setup
- **🔄 CI/CD Pipelines** - Reliable S3 operations in containerized test environments
- **🎭 Mocking & Stubbing** - Replace real S3 calls in test suites
- **📊 Data Migration Testing** - Safely test data migrations locally before production
-
 ## 🔧 API Reference

-### Smarts3 Class
+### `Smarts3` Class

-#### Constructor Options
+#### `static createAndStart(config?: ISmarts3Config): Promise<Smarts3>`

-```typescript
-interface ISmarts3ContructorOptions {
-  port?: number; // Server port (default: 3000)
-  cleanSlate?: boolean; // Clear storage on start (default: false)
-}
+Create and start a server in one call.
+
+#### `start(): Promise<void>`
+
+Spawn the Rust binary and start the HTTP server.
+
+#### `stop(): Promise<void>`
+
+Gracefully stop the server and kill the Rust process.
+
+#### `createBucket(name: string): Promise<{ name: string }>`
+
+Create an S3 bucket.
+
+#### `getS3Descriptor(options?): Promise<IS3Descriptor>`
+
+Get connection details for S3 clients. Returns:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `endpoint` | `string` | Server hostname (`localhost` by default) |
+| `port` | `number` | Server port |
+| `accessKey` | `string` | Access key from first configured credential |
+| `accessSecret` | `string` | Secret key from first configured credential |
+| `useSsl` | `boolean` | Always `false` (plain HTTP) |
+
+## 🏗️ Architecture
+
+smarts3 uses a **hybrid Rust + TypeScript** architecture:
+
+```
+┌─────────────────────────────────┐
+│  Your Code (AWS SDK, etc.)      │
+│  ↕ HTTP (localhost:3000)        │
+├─────────────────────────────────┤
+│  rusts3 binary (Rust)           │
+│  ├─ hyper 1.x HTTP server      │
+│  ├─ S3 path-style routing      │
+│  ├─ Streaming storage layer    │
+│  ├─ Multipart manager          │
+│  ├─ CORS / Auth middleware     │
+│  └─ S3 XML response builder   │
+├─────────────────────────────────┤
+│  TypeScript (thin IPC wrapper)  │
+│  ├─ Smarts3 class              │
+│  ├─ RustBridge (stdin/stdout)  │
+│  └─ Config & S3 descriptor    │
+└─────────────────────────────────┘
 ```

-#### Methods
+**Why Rust?** The TypeScript implementation had critical perf issues: OOM on multipart uploads (parts buffered in memory), double stream copying, file descriptor leaks on HEAD requests, full-file reads for range requests, and no backpressure. The Rust binary solves all of these with streaming I/O, zero-copy, and direct `seek()` for range requests.

- `static createAndStart(options)` - Create and start server in one call
- `start()` - Start the S3 server
- `stop()` - Stop the S3 server
- `createBucket(name)` - Create a new bucket
- `getS3Descriptor(options?)` - Get S3 connection configuration
+**IPC Protocol:** TypeScript spawns the `rusts3` binary with `--management` and communicates via newline-delimited JSON over stdin/stdout. Commands: `start`, `stop`, `createBucket`.

-## 🐛 Debugging Tips
+### S3 Operations Supported

-1. **Enable verbose logging** - The server logs all operations by default
-2. **Check the buckets directory** - Find your data in `.nogit/bucketsDir/`
-3. **Use the correct endpoint** - Remember to use `127.0.0.1` or `localhost`
-4. **Force path style** - Always use path-style URLs with local S3
+| Operation | Method | Path |
+|-----------|--------|------|
+| ListBuckets | `GET /` | |
+| CreateBucket | `PUT /{bucket}` | |
+| DeleteBucket | `DELETE /{bucket}` | |
+| HeadBucket | `HEAD /{bucket}` | |
+| ListObjects (v1/v2) | `GET /{bucket}` | `?list-type=2` for v2 |
+| PutObject | `PUT /{bucket}/{key}` | |
+| GetObject | `GET /{bucket}/{key}` | Supports `Range` header |
+| HeadObject | `HEAD /{bucket}/{key}` | |
+| DeleteObject | `DELETE /{bucket}/{key}` | |
+| CopyObject | `PUT /{bucket}/{key}` | `x-amz-copy-source` header |
+| InitiateMultipartUpload | `POST /{bucket}/{key}?uploads` | |
+| UploadPart | `PUT /{bucket}/{key}?partNumber&uploadId` | |
+| CompleteMultipartUpload | `POST /{bucket}/{key}?uploadId` | |
+| AbortMultipartUpload | `DELETE /{bucket}/{key}?uploadId` | |
+| ListMultipartUploads | `GET /{bucket}?uploads` | |

-## 📈 Performance
+### On-Disk Format

-`@push.rocks/smarts3` is optimized for development and testing:
-
- ⚡ **Instant operations** - No network latency
- 💾 **Low memory footprint** - Efficient file system usage
- 🔄 **Fast cleanup** - Clean slate mode for quick test resets
- 🚀 **Parallel operations** - Handle multiple requests simultaneously
+```
+{storage.directory}/
+  {bucket}/
+    {key}._S3_object              # Object data
+    {key}._S3_object.metadata.json  # Metadata (content-type, x-amz-meta-*, etc.)
+    {key}._S3_object.md5          # Cached MD5 hash
+  .multipart/
+    {upload-id}/
+      metadata.json               # Upload metadata (bucket, key, parts)
+      part-1                      # Part data files
+      part-2
+      ...
+```

 ## 🔗 Related Packages

- [`@push.rocks/smartbucket`](https://www.npmjs.com/package/@push.rocks/smartbucket) - Powerful S3 abstraction layer
- [`@push.rocks/smartfile`](https://www.npmjs.com/package/@push.rocks/smartfile) - Advanced file system operations
- [`@tsclass/tsclass`](https://www.npmjs.com/package/@tsclass/tsclass) - TypeScript class helpers
- [`s3rver`](https://www.npmjs.com/package/s3rver) - Optional legacy S3 server implementation (used when `useCustomServer: false`)
+- [`@push.rocks/smartbucket`](https://code.foss.global/push.rocks/smartbucket) — High-level S3 abstraction layer
+- [`@push.rocks/smartrust`](https://code.foss.global/push.rocks/smartrust) — TypeScript ↔ Rust IPC bridge
+- [`@git.zone/tsrust`](https://code.foss.global/git.zone/tsrust) — Rust cross-compilation for npm packages

 ## License and Legal Information

-This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository.
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [LICENSE](./LICENSE) file.

 **Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.

 ### Trademarks

-This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.
+
+Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.

 ### Company Information

 Task Venture Capital GmbH
-Registered at District court Bremen HRB 35230 HB, Germany
+Registered at District Court Bremen HRB 35230 HB, Germany

-For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+For any legal inquiries or further information, please contact us via email at hello@task.vc.

 By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
--- a/rust/.cargo/config.toml
+++ b/rust/.cargo/config.toml
@@ -0,0 +1,2 @@
+[target.aarch64-unknown-linux-gnu]
+linker = "aarch64-linux-gnu-gcc"
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "rusts3"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "rusts3"
+path = "src/main.rs"
+
+[dependencies]
+tokio = { version = "1", features = ["full"] }
+hyper = { version = "1", features = ["http1", "server"] }
+hyper-util = { version = "0.1", features = ["tokio", "http1"] }
+http-body-util = "0.1"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+quick-xml = { version = "0.37", features = ["serialize"] }
+md-5 = "0.10"
+tokio-util = { version = "0.7", features = ["io"] }
+bytes = "1"
+uuid = { version = "1", features = ["v4"] }
+clap = { version = "4", features = ["derive"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+thiserror = "2"
+anyhow = "1"
+percent-encoding = "2"
+url = "2"
+chrono = { version = "0.4", features = ["serde"] }
+futures-core = "0.3"
--- a/rust/src/config.rs
+++ b/rust/src/config.rs
@@ -0,0 +1,78 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct S3Config {
+    pub server: ServerConfig,
+    pub storage: StorageConfig,
+    pub auth: AuthConfig,
+    pub cors: CorsConfig,
+    pub logging: LoggingConfig,
+    pub limits: LimitsConfig,
+    pub multipart: MultipartConfig,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ServerConfig {
+    pub port: u16,
+    pub address: String,
+    pub silent: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StorageConfig {
+    pub directory: String,
+    pub clean_slate: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AuthConfig {
+    pub enabled: bool,
+    pub credentials: Vec<Credential>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Credential {
+    #[serde(rename = "accessKeyId")]
+    pub access_key_id: String,
+    #[serde(rename = "secretAccessKey")]
+    pub secret_access_key: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CorsConfig {
+    pub enabled: bool,
+    pub allowed_origins: Option<Vec<String>>,
+    pub allowed_methods: Option<Vec<String>>,
+    pub allowed_headers: Option<Vec<String>>,
+    pub exposed_headers: Option<Vec<String>>,
+    pub max_age: Option<u64>,
+    pub allow_credentials: Option<bool>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LoggingConfig {
+    pub level: Option<String>,
+    pub format: Option<String>,
+    pub enabled: Option<bool>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LimitsConfig {
+    pub max_object_size: Option<u64>,
+    pub max_metadata_size: Option<u64>,
+    pub request_timeout: Option<u64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MultipartConfig {
+    pub expiration_days: Option<u64>,
+    pub cleanup_interval_minutes: Option<u64>,
+}
--- a/rust/src/main.rs
+++ b/rust/src/main.rs
@@ -0,0 +1,43 @@
+mod config;
+mod management;
+mod s3_error;
+mod server;
+mod storage;
+mod xml_response;
+
+use clap::Parser;
+
+#[derive(Parser)]
+#[command(name = "rusts3", about = "High-performance S3-compatible server")]
+struct Cli {
+    /// Run in management mode (IPC via stdin/stdout)
+    #[arg(long)]
+    management: bool,
+
+    /// Log level
+    #[arg(long, default_value = "info")]
+    log_level: String,
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let cli = Cli::parse();
+
+    if cli.management {
+        // Init tracing to stderr only (stdout reserved for IPC)
+        tracing_subscriber::fmt()
+            .with_writer(std::io::stderr)
+            .with_env_filter(
+                tracing_subscriber::EnvFilter::try_new(&cli.log_level)
+                    .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
+            )
+            .init();
+
+        management::management_loop().await?;
+    } else {
+        eprintln!("rusts3: use --management flag for IPC mode");
+        std::process::exit(1);
+    }
+
+    Ok(())
+}
--- a/rust/src/management.rs
+++ b/rust/src/management.rs
@@ -0,0 +1,155 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::io::Write;
+use tokio::io::{AsyncBufReadExt, BufReader};
+
+use crate::config::S3Config;
+use crate::server::S3Server;
+
+#[derive(Deserialize)]
+struct IpcRequest {
+    id: String,
+    method: String,
+    params: Value,
+}
+
+#[derive(Serialize)]
+struct IpcResponse {
+    id: String,
+    success: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    result: Option<Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    error: Option<String>,
+}
+
+#[derive(Serialize)]
+struct IpcEvent {
+    event: String,
+    data: Value,
+}
+
+fn send_line(value: &impl Serialize) {
+    let mut stdout = std::io::stdout().lock();
+    serde_json::to_writer(&mut stdout, value).ok();
+    stdout.write_all(b"\n").ok();
+    stdout.flush().ok();
+}
+
+fn send_response(id: String, result: Value) {
+    send_line(&IpcResponse {
+        id,
+        success: true,
+        result: Some(result),
+        error: None,
+    });
+}
+
+fn send_error(id: String, message: String) {
+    send_line(&IpcResponse {
+        id,
+        success: false,
+        result: None,
+        error: Some(message),
+    });
+}
+
+pub async fn management_loop() -> Result<()> {
+    // Emit ready event
+    send_line(&IpcEvent {
+        event: "ready".to_string(),
+        data: serde_json::json!({}),
+    });
+
+    let mut server: Option<S3Server> = None;
+    let stdin = BufReader::new(tokio::io::stdin());
+    let mut lines = stdin.lines();
+
+    while let Ok(Some(line)) = lines.next_line().await {
+        let line = line.trim().to_string();
+        if line.is_empty() {
+            continue;
+        }
+
+        let req: IpcRequest = match serde_json::from_str(&line) {
+            Ok(r) => r,
+            Err(e) => {
+                tracing::warn!("Invalid IPC request: {}", e);
+                continue;
+            }
+        };
+
+        let id = req.id.clone();
+        let method = req.method.as_str();
+
+        match method {
+            "start" => {
+                #[derive(Deserialize)]
+                struct StartParams {
+                    config: S3Config,
+                }
+                match serde_json::from_value::<StartParams>(req.params) {
+                    Ok(params) => {
+                        match S3Server::start(params.config).await {
+                            Ok(s) => {
+                                server = Some(s);
+                                send_response(id, serde_json::json!({}));
+                            }
+                            Err(e) => {
+                                send_error(id, format!("Failed to start server: {}", e));
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        send_error(id, format!("Invalid start params: {}", e));
+                    }
+                }
+            }
+            "stop" => {
+                if let Some(s) = server.take() {
+                    s.stop().await;
+                }
+                send_response(id, serde_json::json!({}));
+            }
+            "createBucket" => {
+                #[derive(Deserialize)]
+                struct CreateBucketParams {
+                    name: String,
+                }
+                match serde_json::from_value::<CreateBucketParams>(req.params) {
+                    Ok(params) => {
+                        if let Some(ref s) = server {
+                            match s.store().create_bucket(&params.name).await {
+                                Ok(()) => {
+                                    send_response(id, serde_json::json!({}));
+                                }
+                                Err(e) => {
+                                    send_error(
+                                        id,
+                                        format!("Failed to create bucket: {}", e),
+                                    );
+                                }
+                            }
+                        } else {
+                            send_error(id, "Server not started".to_string());
+                        }
+                    }
+                    Err(e) => {
+                        send_error(id, format!("Invalid createBucket params: {}", e));
+                    }
+                }
+            }
+            _ => {
+                send_error(id, format!("Unknown method: {}", method));
+            }
+        }
+    }
+
+    // Clean shutdown
+    if let Some(s) = server.take() {
+        s.stop().await;
+    }
+
+    Ok(())
+}
--- a/rust/src/s3_error.rs
+++ b/rust/src/s3_error.rs
@@ -0,0 +1,70 @@
+use hyper::{Response, StatusCode};
+use http_body_util::Full;
+use bytes::Bytes;
+
+#[derive(Debug, thiserror::Error)]
+#[error("S3Error({code}): {message}")]
+pub struct S3Error {
+    pub code: String,
+    pub message: String,
+    pub status: StatusCode,
+}
+
+impl S3Error {
+    pub fn new(code: &str, message: &str, status: StatusCode) -> Self {
+        Self {
+            code: code.to_string(),
+            message: message.to_string(),
+            status,
+        }
+    }
+
+    pub fn no_such_key() -> Self {
+        Self::new("NoSuchKey", "The specified key does not exist.", StatusCode::NOT_FOUND)
+    }
+
+    pub fn no_such_bucket() -> Self {
+        Self::new("NoSuchBucket", "The specified bucket does not exist", StatusCode::NOT_FOUND)
+    }
+
+    pub fn bucket_not_empty() -> Self {
+        Self::new("BucketNotEmpty", "The bucket you tried to delete is not empty", StatusCode::CONFLICT)
+    }
+
+    pub fn access_denied() -> Self {
+        Self::new("AccessDenied", "Access Denied", StatusCode::FORBIDDEN)
+    }
+
+    pub fn no_such_upload() -> Self {
+        Self::new("NoSuchUpload", "The specified upload does not exist", StatusCode::NOT_FOUND)
+    }
+
+    pub fn invalid_part_number() -> Self {
+        Self::new("InvalidPartNumber", "Part number must be between 1 and 10000", StatusCode::BAD_REQUEST)
+    }
+
+    pub fn internal_error(msg: &str) -> Self {
+        Self::new("InternalError", msg, StatusCode::INTERNAL_SERVER_ERROR)
+    }
+
+    pub fn invalid_request(msg: &str) -> Self {
+        Self::new("InvalidRequest", msg, StatusCode::BAD_REQUEST)
+    }
+
+    pub fn to_xml(&self) -> String {
+        format!(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<Error><Code>{}</Code><Message>{}</Message></Error>",
+            self.code, self.message
+        )
+    }
+
+    pub fn to_response(&self, request_id: &str) -> Response<Full<Bytes>> {
+        let xml = self.to_xml();
+        Response::builder()
+            .status(self.status)
+            .header("content-type", "application/xml")
+            .header("x-amz-request-id", request_id)
+            .body(Full::new(Bytes::from(xml)))
+            .unwrap()
+    }
+}
--- a/rust/src/server.rs
+++ b/rust/src/server.rs
@@ -0,0 +1,865 @@
+use anyhow::Result;
+use bytes::Bytes;
+use futures_core::Stream;
+use http_body_util::BodyExt;
+use hyper::body::Incoming;
+use hyper::server::conn::http1;
+use hyper::service::service_fn;
+use hyper::{Method, Request, Response, StatusCode};
+use hyper_util::rt::TokioIo;
+use std::collections::HashMap;
+use std::net::SocketAddr;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+use tokio::io::AsyncReadExt;
+use tokio::net::TcpListener;
+use tokio::sync::watch;
+use tokio_util::io::ReaderStream;
+use uuid::Uuid;
+
+use crate::config::S3Config;
+use crate::s3_error::S3Error;
+use crate::storage::FileStore;
+use crate::xml_response;
+
+pub struct S3Server {
+    store: Arc<FileStore>,
+    config: S3Config,
+    shutdown_tx: watch::Sender<bool>,
+    server_handle: tokio::task::JoinHandle<()>,
+}
+
+impl S3Server {
+    pub async fn start(config: S3Config) -> Result<Self> {
+        let store = Arc::new(FileStore::new(config.storage.directory.clone().into()));
+
+        // Initialize or reset storage
+        if config.storage.clean_slate {
+            store.reset().await?;
+        } else {
+            store.initialize().await?;
+        }
+
+        let addr: SocketAddr = format!("{}:{}", config.address(), config.server.port)
+            .parse()?;
+
+        let listener = TcpListener::bind(addr).await?;
+        let (shutdown_tx, shutdown_rx) = watch::channel(false);
+
+        let server_store = store.clone();
+        let server_config = config.clone();
+
+        let server_handle = tokio::spawn(async move {
+            loop {
+                let mut rx = shutdown_rx.clone();
+
+                tokio::select! {
+                    result = listener.accept() => {
+                        match result {
+                            Ok((stream, _remote_addr)) => {
+                                let io = TokioIo::new(stream);
+                                let store = server_store.clone();
+                                let cfg = server_config.clone();
+
+                                tokio::spawn(async move {
+                                    let svc = service_fn(move |req: Request<Incoming>| {
+                                        let store = store.clone();
+                                        let cfg = cfg.clone();
+                                        async move {
+                                            handle_request(req, store, cfg).await
+                                        }
+                                    });
+
+                                    if let Err(e) = http1::Builder::new()
+                                        .keep_alive(true)
+                                        .serve_connection(io, svc)
+                                        .await
+                                    {
+                                        if !e.is_incomplete_message() {
+                                            tracing::error!("Connection error: {}", e);
+                                        }
+                                    }
+                                });
+                            }
+                            Err(e) => {
+                                tracing::error!("Accept error: {}", e);
+                            }
+                        }
+                    }
+                    _ = rx.changed() => {
+                        break;
+                    }
+                }
+            }
+        });
+
+        if !config.server.silent {
+            tracing::info!("S3 server listening on {}", addr);
+        }
+
+        Ok(Self {
+            store,
+            config,
+            shutdown_tx,
+            server_handle,
+        })
+    }
+
+    pub async fn stop(self) {
+        let _ = self.shutdown_tx.send(true);
+        let _ = self.server_handle.await;
+    }
+
+    pub fn store(&self) -> &FileStore {
+        &self.store
+    }
+}
+
+impl S3Config {
+    fn address(&self) -> &str {
+        &self.server.address
+    }
+}
+
+// ============================
+// Request handling
+// ============================
+
+type BoxBody = http_body_util::combinators::BoxBody<Bytes, Box<dyn std::error::Error + Send + Sync>>;
+
+fn full_body(data: impl Into<Bytes>) -> BoxBody {
+    http_body_util::Full::new(data.into())
+        .map_err(|never: std::convert::Infallible| -> Box<dyn std::error::Error + Send + Sync> { match never {} })
+        .boxed()
+}
+
+fn empty_body() -> BoxBody {
+    http_body_util::Empty::new()
+        .map_err(|never: std::convert::Infallible| -> Box<dyn std::error::Error + Send + Sync> { match never {} })
+        .boxed()
+}
+
+fn stream_body(reader: tokio::fs::File, content_length: u64) -> BoxBody {
+    let stream = ReaderStream::with_capacity(reader.take(content_length), 64 * 1024);
+    let mapped = FrameStream { inner: stream };
+    http_body_util::StreamBody::new(mapped).boxed()
+}
+
+/// Adapter that converts ReaderStream into a Stream of Frame<Bytes>
+struct FrameStream {
+    inner: ReaderStream<tokio::io::Take<tokio::fs::File>>,
+}
+
+impl Stream for FrameStream {
+    type Item = Result<hyper::body::Frame<Bytes>, Box<dyn std::error::Error + Send + Sync>>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let inner = unsafe { self.map_unchecked_mut(|s| &mut s.inner) };
+        match inner.poll_next(cx) {
+            Poll::Ready(Some(Ok(bytes))) => {
+                Poll::Ready(Some(Ok(hyper::body::Frame::data(bytes))))
+            }
+            Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(Box::new(e) as Box<dyn std::error::Error + Send + Sync>))),
+            Poll::Ready(None) => Poll::Ready(None),
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
+
+fn xml_response(status: StatusCode, xml: String, request_id: &str) -> Response<BoxBody> {
+    Response::builder()
+        .status(status)
+        .header("content-type", "application/xml")
+        .header("x-amz-request-id", request_id)
+        .body(full_body(xml))
+        .unwrap()
+}
+
+fn empty_response(status: StatusCode, request_id: &str) -> Response<BoxBody> {
+    Response::builder()
+        .status(status)
+        .header("x-amz-request-id", request_id)
+        .body(empty_body())
+        .unwrap()
+}
+
+fn s3_error_response(err: &S3Error, request_id: &str) -> Response<BoxBody> {
+    let xml = err.to_xml();
+    Response::builder()
+        .status(err.status)
+        .header("content-type", "application/xml")
+        .header("x-amz-request-id", request_id)
+        .body(full_body(xml))
+        .unwrap()
+}
+
+async fn handle_request(
+    req: Request<Incoming>,
+    store: Arc<FileStore>,
+    config: S3Config,
+) -> Result<Response<BoxBody>, std::convert::Infallible> {
+    let request_id = Uuid::new_v4().to_string();
+    let method = req.method().clone();
+    let uri = req.uri().clone();
+    let start = std::time::Instant::now();
+
+    // Handle CORS preflight
+    if config.cors.enabled && method == Method::OPTIONS {
+        let resp = build_cors_preflight(&config, &request_id);
+        return Ok(resp);
+    }
+
+    // Auth check
+    if config.auth.enabled {
+        if let Err(e) = check_auth(&req, &config) {
+            tracing::warn!("Auth failed: {}", e.message);
+            return Ok(s3_error_response(&e, &request_id));
+        }
+    }
+
+    // Route and handle
+    let mut response = match route_request(req, store, &config, &request_id).await {
+        Ok(resp) => resp,
+        Err(err) => {
+            if let Some(s3err) = err.downcast_ref::<S3Error>() {
+                s3_error_response(s3err, &request_id)
+            } else {
+                tracing::error!("Internal error: {}", err);
+                let s3err = S3Error::internal_error(&err.to_string());
+                s3_error_response(&s3err, &request_id)
+            }
+        }
+    };
+
+    // Add CORS headers if enabled
+    if config.cors.enabled {
+        add_cors_headers(response.headers_mut(), &config);
+    }
+
+    let duration = start.elapsed();
+    tracing::info!(
+        method = %method,
+        path = %uri.path(),
+        status = %response.status().as_u16(),
+        duration_ms = %duration.as_millis(),
+        "request"
+    );
+
+    Ok(response)
+}
+
+// ============================
+// Routing
+// ============================
+
+async fn route_request(
+    req: Request<Incoming>,
+    store: Arc<FileStore>,
+    _config: &S3Config,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    let method = req.method().clone();
+    let path = req.uri().path().to_string();
+    let query_string = req.uri().query().unwrap_or("").to_string();
+    let query = parse_query(&query_string);
+
+    // Parse path: /, /{bucket}, /{bucket}/{key...}
+    let segments: Vec<&str> = path
+        .trim_start_matches('/')
+        .splitn(2, '/')
+        .filter(|s| !s.is_empty())
+        .collect();
+
+    match segments.len() {
+        0 => {
+            // Root: GET / -> ListBuckets
+            match method {
+                Method::GET => handle_list_buckets(store, request_id).await,
+                _ => Ok(empty_response(StatusCode::METHOD_NOT_ALLOWED, request_id)),
+            }
+        }
+        1 => {
+            // Bucket level: /{bucket}
+            let bucket = percent_decode(segments[0]);
+            match method {
+                Method::GET => {
+                    if query.contains_key("uploads") {
+                        handle_list_multipart_uploads(store, &bucket, request_id).await
+                    } else {
+                        handle_list_objects(store, &bucket, &query, request_id).await
+                    }
+                }
+                Method::PUT => handle_create_bucket(store, &bucket, request_id).await,
+                Method::DELETE => handle_delete_bucket(store, &bucket, request_id).await,
+                Method::HEAD => handle_head_bucket(store, &bucket, request_id).await,
+                _ => Ok(empty_response(StatusCode::METHOD_NOT_ALLOWED, request_id)),
+            }
+        }
+        2 => {
+            // Object level: /{bucket}/{key...}
+            let bucket = percent_decode(segments[0]);
+            let key = percent_decode(segments[1]);
+
+            match method {
+                Method::PUT => {
+                    if query.contains_key("partNumber") && query.contains_key("uploadId") {
+                        handle_upload_part(req, store, &query, request_id).await
+                    } else if req.headers().contains_key("x-amz-copy-source") {
+                        handle_copy_object(req, store, &bucket, &key, request_id).await
+                    } else {
+                        handle_put_object(req, store, &bucket, &key, request_id).await
+                    }
+                }
+                Method::GET => {
+                    handle_get_object(req, store, &bucket, &key, request_id).await
+                }
+                Method::HEAD => {
+                    handle_head_object(store, &bucket, &key, request_id).await
+                }
+                Method::DELETE => {
+                    if query.contains_key("uploadId") {
+                        let upload_id = query.get("uploadId").unwrap();
+                        handle_abort_multipart(store, upload_id, request_id).await
+                    } else {
+                        handle_delete_object(store, &bucket, &key, request_id).await
+                    }
+                }
+                Method::POST => {
+                    if query.contains_key("uploads") {
+                        handle_initiate_multipart(req, store, &bucket, &key, request_id).await
+                    } else if query.contains_key("uploadId") {
+                        let upload_id = query.get("uploadId").unwrap().clone();
+                        handle_complete_multipart(req, store, &bucket, &key, &upload_id, request_id).await
+                    } else {
+                        let err = S3Error::invalid_request("Invalid POST request");
+                        Ok(s3_error_response(&err, request_id))
+                    }
+                }
+                _ => Ok(empty_response(StatusCode::METHOD_NOT_ALLOWED, request_id)),
+            }
+        }
+        _ => Ok(empty_response(StatusCode::BAD_REQUEST, request_id)),
+    }
+}
+
+// ============================
+// Handlers
+// ============================
+
+async fn handle_list_buckets(
+    store: Arc<FileStore>,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    let buckets = store.list_buckets().await?;
+    let xml = xml_response::list_buckets_xml(&buckets);
+    Ok(xml_response(StatusCode::OK, xml, request_id))
+}
+
+async fn handle_create_bucket(
+    store: Arc<FileStore>,
+    bucket: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    store.create_bucket(bucket).await?;
+    Ok(empty_response(StatusCode::OK, request_id))
+}
+
+async fn handle_delete_bucket(
+    store: Arc<FileStore>,
+    bucket: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    store.delete_bucket(bucket).await?;
+    Ok(empty_response(StatusCode::NO_CONTENT, request_id))
+}
+
+async fn handle_head_bucket(
+    store: Arc<FileStore>,
+    bucket: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    if store.bucket_exists(bucket).await {
+        Ok(empty_response(StatusCode::OK, request_id))
+    } else {
+        Err(S3Error::no_such_bucket().into())
+    }
+}
+
+async fn handle_list_objects(
+    store: Arc<FileStore>,
+    bucket: &str,
+    query: &HashMap<String, String>,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    let prefix = query.get("prefix").map(|s| s.as_str()).unwrap_or("");
+    let delimiter = query.get("delimiter").map(|s| s.as_str()).unwrap_or("");
+    let max_keys = query
+        .get("max-keys")
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(1000usize);
+    let continuation_token = query.get("continuation-token").map(|s| s.as_str());
+    let is_v2 = query.get("list-type").map(|s| s.as_str()) == Some("2");
+
+    let result = store
+        .list_objects(bucket, prefix, delimiter, max_keys, continuation_token)
+        .await?;
+
+    let xml = if is_v2 {
+        xml_response::list_objects_v2_xml(bucket, &result)
+    } else {
+        xml_response::list_objects_v1_xml(bucket, &result)
+    };
+
+    Ok(xml_response(StatusCode::OK, xml, request_id))
+}
+
+async fn handle_put_object(
+    req: Request<Incoming>,
+    store: Arc<FileStore>,
+    bucket: &str,
+    key: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    let metadata = extract_metadata(req.headers());
+    let body = req.into_body();
+
+    let result = store.put_object(bucket, key, body, metadata).await?;
+
+    let resp = Response::builder()
+        .status(StatusCode::OK)
+        .header("ETag", format!("\"{}\"", result.md5))
+        .header("x-amz-request-id", request_id)
+        .body(empty_body())
+        .unwrap();
+
+    Ok(resp)
+}
+
+async fn handle_get_object(
+    req: Request<Incoming>,
+    store: Arc<FileStore>,
+    bucket: &str,
+    key: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    // Parse Range header
+    let range = parse_range_header(req.headers());
+
+    let result = store.get_object(bucket, key, range).await?;
+
+    let content_type = result
+        .metadata
+        .get("content-type")
+        .cloned()
+        .unwrap_or_else(|| "binary/octet-stream".to_string());
+
+    let mut builder = Response::builder()
+        .header("ETag", format!("\"{}\"", result.md5))
+        .header("Last-Modified", result.last_modified.format("%a, %d %b %Y %H:%M:%S GMT").to_string())
+        .header("Content-Type", &content_type)
+        .header("Accept-Ranges", "bytes")
+        .header("x-amz-request-id", request_id);
+
+    // Add custom metadata headers
+    for (k, v) in &result.metadata {
+        if k.starts_with("x-amz-meta-") {
+            builder = builder.header(k.as_str(), v.as_str());
+        }
+    }
+
+    if let Some((start, end)) = range {
+        let content_length = end - start + 1;
+        let resp = builder
+            .status(StatusCode::PARTIAL_CONTENT)
+            .header("Content-Length", content_length.to_string())
+            .header(
+                "Content-Range",
+                format!("bytes {}-{}/{}", start, end, result.size),
+            )
+            .body(stream_body(result.body, content_length))
+            .unwrap();
+        Ok(resp)
+    } else {
+        let resp = builder
+            .status(StatusCode::OK)
+            .header("Content-Length", result.size.to_string())
+            .body(stream_body(result.body, result.content_length))
+            .unwrap();
+        Ok(resp)
+    }
+}
+
+async fn handle_head_object(
+    store: Arc<FileStore>,
+    bucket: &str,
+    key: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    let result = store.head_object(bucket, key).await?;
+
+    let content_type = result
+        .metadata
+        .get("content-type")
+        .cloned()
+        .unwrap_or_else(|| "binary/octet-stream".to_string());
+
+    let mut builder = Response::builder()
+        .status(StatusCode::OK)
+        .header("ETag", format!("\"{}\"", result.md5))
+        .header("Last-Modified", result.last_modified.format("%a, %d %b %Y %H:%M:%S GMT").to_string())
+        .header("Content-Type", &content_type)
+        .header("Content-Length", result.size.to_string())
+        .header("Accept-Ranges", "bytes")
+        .header("x-amz-request-id", request_id);
+
+    for (k, v) in &result.metadata {
+        if k.starts_with("x-amz-meta-") {
+            builder = builder.header(k.as_str(), v.as_str());
+        }
+    }
+
+    Ok(builder.body(empty_body()).unwrap())
+}
+
+async fn handle_delete_object(
+    store: Arc<FileStore>,
+    bucket: &str,
+    key: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    store.delete_object(bucket, key).await?;
+    Ok(empty_response(StatusCode::NO_CONTENT, request_id))
+}
+
+async fn handle_copy_object(
+    req: Request<Incoming>,
+    store: Arc<FileStore>,
+    dest_bucket: &str,
+    dest_key: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    let copy_source = req
+        .headers()
+        .get("x-amz-copy-source")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("")
+        .to_string();
+
+    let metadata_directive = req
+        .headers()
+        .get("x-amz-metadata-directive")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("COPY")
+        .to_uppercase();
+
+    // Parse source: /bucket/key or bucket/key
+    let source = copy_source.trim_start_matches('/');
+    let first_slash = source.find('/').unwrap_or(source.len());
+    let src_bucket = percent_decode(&source[..first_slash]);
+    let src_key = if first_slash < source.len() {
+        percent_decode(&source[first_slash + 1..])
+    } else {
+        String::new()
+    };
+
+    let new_metadata = if metadata_directive == "REPLACE" {
+        Some(extract_metadata(req.headers()))
+    } else {
+        None
+    };
+
+    let result = store
+        .copy_object(&src_bucket, &src_key, dest_bucket, dest_key, &metadata_directive, new_metadata)
+        .await?;
+
+    let xml = xml_response::copy_object_result_xml(&result.md5, &result.last_modified.to_rfc3339());
+    Ok(xml_response(StatusCode::OK, xml, request_id))
+}
+
+// ============================
+// Multipart handlers
+// ============================
+
+async fn handle_initiate_multipart(
+    req: Request<Incoming>,
+    store: Arc<FileStore>,
+    bucket: &str,
+    key: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    let metadata = extract_metadata(req.headers());
+    let upload_id = store.initiate_multipart(bucket, key, metadata).await?;
+    let xml = xml_response::initiate_multipart_xml(bucket, key, &upload_id);
+    Ok(xml_response(StatusCode::OK, xml, request_id))
+}
+
+async fn handle_upload_part(
+    req: Request<Incoming>,
+    store: Arc<FileStore>,
+    query: &HashMap<String, String>,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    let upload_id = query.get("uploadId").unwrap();
+    let part_number: u32 = query
+        .get("partNumber")
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(0);
+
+    if part_number < 1 || part_number > 10000 {
+        return Err(S3Error::invalid_part_number().into());
+    }
+
+    let body = req.into_body();
+    let (etag, _size) = store.upload_part(upload_id, part_number, body).await?;
+
+    let resp = Response::builder()
+        .status(StatusCode::OK)
+        .header("ETag", format!("\"{}\"", etag))
+        .header("x-amz-request-id", request_id)
+        .body(empty_body())
+        .unwrap();
+
+    Ok(resp)
+}
+
+async fn handle_complete_multipart(
+    req: Request<Incoming>,
+    store: Arc<FileStore>,
+    bucket: &str,
+    key: &str,
+    upload_id: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    // Read request body (XML)
+    let body_bytes = req.collect().await.map_err(|e| anyhow::anyhow!("Body error: {}", e))?.to_bytes();
+    let body_str = String::from_utf8_lossy(&body_bytes);
+
+    // Parse parts from XML using regex-like approach
+    let parts = parse_complete_multipart_xml(&body_str);
+
+    let result = store.complete_multipart(upload_id, &parts).await?;
+
+    let xml = xml_response::complete_multipart_xml(bucket, key, &result.etag);
+    Ok(xml_response(StatusCode::OK, xml, request_id))
+}
+
+async fn handle_abort_multipart(
+    store: Arc<FileStore>,
+    upload_id: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    store.abort_multipart(upload_id).await?;
+    Ok(empty_response(StatusCode::NO_CONTENT, request_id))
+}
+
+async fn handle_list_multipart_uploads(
+    store: Arc<FileStore>,
+    bucket: &str,
+    request_id: &str,
+) -> Result<Response<BoxBody>> {
+    let uploads = store.list_multipart_uploads(bucket).await?;
+    let xml = xml_response::list_multipart_uploads_xml(bucket, &uploads);
+    Ok(xml_response(StatusCode::OK, xml, request_id))
+}
+
+// ============================
+// Helpers
+// ============================
+
+fn parse_query(query_string: &str) -> HashMap<String, String> {
+    let mut map = HashMap::new();
+    if query_string.is_empty() {
+        return map;
+    }
+    for pair in query_string.split('&') {
+        let mut parts = pair.splitn(2, '=');
+        let key = parts.next().unwrap_or("");
+        let value = parts.next().unwrap_or("");
+        let key = percent_decode(key);
+        let value = percent_decode(value);
+        map.insert(key, value);
+    }
+    map
+}
+
+fn percent_decode(s: &str) -> String {
+    percent_encoding::percent_decode_str(s)
+        .decode_utf8_lossy()
+        .to_string()
+}
+
+fn extract_metadata(headers: &hyper::HeaderMap) -> HashMap<String, String> {
+    let mut metadata = HashMap::new();
+
+    for (name, value) in headers {
+        let name_str = name.as_str().to_lowercase();
+        if let Ok(val) = value.to_str() {
+            match name_str.as_str() {
+                "content-type" | "cache-control" | "content-disposition"
+                | "content-encoding" | "content-language" | "expires" => {
+                    metadata.insert(name_str, val.to_string());
+                }
+                _ if name_str.starts_with("x-amz-meta-") => {
+                    metadata.insert(name_str, val.to_string());
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // Default content-type
+    if !metadata.contains_key("content-type") {
+        metadata.insert("content-type".to_string(), "binary/octet-stream".to_string());
+    }
+
+    metadata
+}
+
+fn parse_range_header(headers: &hyper::HeaderMap) -> Option<(u64, u64)> {
+    let range_val = headers.get("range")?.to_str().ok()?;
+    let bytes_prefix = "bytes=";
+    if !range_val.starts_with(bytes_prefix) {
+        return None;
+    }
+    let range_spec = &range_val[bytes_prefix.len()..];
+    let mut parts = range_spec.splitn(2, '-');
+    let start: u64 = parts.next()?.parse().ok()?;
+    let end_str = parts.next()?;
+    let end: u64 = if end_str.is_empty() {
+        // If no end specified, we'll handle this later based on file size
+        u64::MAX
+    } else {
+        end_str.parse().ok()?
+    };
+    Some((start, end))
+}
+
+fn parse_complete_multipart_xml(xml: &str) -> Vec<(u32, String)> {
+    let mut parts = Vec::new();
+
+    // Simple XML parsing for <Part><PartNumber>N</PartNumber><ETag>...</ETag></Part>
+    let mut remaining = xml;
+    while let Some(part_start) = remaining.find("<Part>") {
+        let after_part = &remaining[part_start + 6..];
+        if let Some(part_end) = after_part.find("</Part>") {
+            let part_content = &after_part[..part_end];
+
+            let part_number = extract_xml_value(part_content, "PartNumber")
+                .and_then(|s| s.parse::<u32>().ok());
+            let etag = extract_xml_value(part_content, "ETag")
+                .map(|s| s.replace('"', ""));
+
+            if let (Some(pn), Some(et)) = (part_number, etag) {
+                parts.push((pn, et));
+            }
+
+            remaining = &after_part[part_end + 7..];
+        } else {
+            break;
+        }
+    }
+
+    parts.sort_by_key(|(pn, _)| *pn);
+    parts
+}
+
+fn extract_xml_value<'a>(xml: &'a str, tag: &str) -> Option<String> {
+    let open = format!("<{}>", tag);
+    let close = format!("</{}>", tag);
+    let start = xml.find(&open)? + open.len();
+    let end = xml.find(&close)?;
+    Some(xml[start..end].to_string())
+}
+
+// ============================
+// CORS
+// ============================
+
+fn build_cors_preflight(config: &S3Config, request_id: &str) -> Response<BoxBody> {
+    let mut builder = Response::builder()
+        .status(StatusCode::NO_CONTENT)
+        .header("x-amz-request-id", request_id);
+
+    if let Some(ref origins) = config.cors.allowed_origins {
+        builder = builder.header("Access-Control-Allow-Origin", origins.join(", "));
+    }
+    if let Some(ref methods) = config.cors.allowed_methods {
+        builder = builder.header("Access-Control-Allow-Methods", methods.join(", "));
+    }
+    if let Some(ref headers) = config.cors.allowed_headers {
+        builder = builder.header("Access-Control-Allow-Headers", headers.join(", "));
+    }
+    if let Some(max_age) = config.cors.max_age {
+        builder = builder.header("Access-Control-Max-Age", max_age.to_string());
+    }
+    if config.cors.allow_credentials == Some(true) {
+        builder = builder.header("Access-Control-Allow-Credentials", "true");
+    }
+
+    builder.body(empty_body()).unwrap()
+}
+
+fn add_cors_headers(headers: &mut hyper::HeaderMap, config: &S3Config) {
+    if let Some(ref origins) = config.cors.allowed_origins {
+        headers.insert(
+            "access-control-allow-origin",
+            origins.join(", ").parse().unwrap(),
+        );
+    }
+    if let Some(ref exposed) = config.cors.exposed_headers {
+        headers.insert(
+            "access-control-expose-headers",
+            exposed.join(", ").parse().unwrap(),
+        );
+    }
+    if config.cors.allow_credentials == Some(true) {
+        headers.insert(
+            "access-control-allow-credentials",
+            "true".parse().unwrap(),
+        );
+    }
+}
+
+// ============================
+// Auth
+// ============================
+
+fn check_auth(req: &Request<Incoming>, config: &S3Config) -> Result<(), S3Error> {
+    let auth_header = req
+        .headers()
+        .get("authorization")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("");
+
+    if auth_header.is_empty() {
+        return Err(S3Error::access_denied());
+    }
+
+    // Extract access key from AWS v2 or v4 signature
+    let access_key = if auth_header.starts_with("AWS4-HMAC-SHA256") {
+        // v4: AWS4-HMAC-SHA256 Credential=KEY/date/region/s3/aws4_request, ...
+        auth_header
+            .split("Credential=")
+            .nth(1)
+            .and_then(|s| s.split('/').next())
+    } else if auth_header.starts_with("AWS ") {
+        // v2: AWS KEY:signature
+        auth_header
+            .strip_prefix("AWS ")
+            .and_then(|s| s.split(':').next())
+    } else {
+        None
+    };
+
+    let access_key = access_key.unwrap_or("");
+
+    // Check against configured credentials
+    for cred in &config.auth.credentials {
+        if cred.access_key_id == access_key {
+            return Ok(());
+        }
+    }
+
+    Err(S3Error::access_denied())
+}
--- a/rust/src/storage.rs
+++ b/rust/src/storage.rs
@@ -0,0 +1,885 @@
+use anyhow::Result;
+use chrono::{DateTime, Utc};
+use http_body_util::BodyExt;
+use hyper::body::Incoming;
+use md5::{Digest, Md5};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use tokio::fs;
+use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt, BufWriter};
+use uuid::Uuid;
+
+use crate::s3_error::S3Error;
+
+// ============================
+// Result types
+// ============================
+
+pub struct PutResult {
+    pub size: u64,
+    pub md5: String,
+}
+
+pub struct GetResult {
+    pub key: String,
+    pub size: u64,
+    pub last_modified: DateTime<Utc>,
+    pub md5: String,
+    pub metadata: HashMap<String, String>,
+    pub body: tokio::fs::File,
+    pub content_length: u64,
+}
+
+pub struct HeadResult {
+    pub key: String,
+    pub size: u64,
+    pub last_modified: DateTime<Utc>,
+    pub md5: String,
+    pub metadata: HashMap<String, String>,
+}
+
+pub struct CopyResult {
+    pub size: u64,
+    pub md5: String,
+    pub last_modified: DateTime<Utc>,
+}
+
+pub struct ListObjectEntry {
+    pub key: String,
+    pub size: u64,
+    pub last_modified: DateTime<Utc>,
+    pub md5: String,
+}
+
+pub struct ListObjectsResult {
+    pub contents: Vec<ListObjectEntry>,
+    pub common_prefixes: Vec<String>,
+    pub is_truncated: bool,
+    pub next_continuation_token: Option<String>,
+    pub prefix: String,
+    pub delimiter: String,
+    pub max_keys: usize,
+}
+
+pub struct BucketInfo {
+    pub name: String,
+    pub creation_date: DateTime<Utc>,
+}
+
+pub struct MultipartUploadInfo {
+    pub upload_id: String,
+    pub bucket: String,
+    pub key: String,
+    pub initiated: DateTime<Utc>,
+}
+
+pub struct CompleteMultipartResult {
+    pub etag: String,
+    pub size: u64,
+}
+
+// ============================
+// Multipart metadata (disk format, compatible with TS)
+// ============================
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct MultipartMetadata {
+    upload_id: String,
+    bucket: String,
+    key: String,
+    initiated: String,
+    metadata: HashMap<String, String>,
+    parts: Vec<PartMetadata>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct PartMetadata {
+    part_number: u32,
+    etag: String,
+    size: u64,
+    last_modified: String,
+}
+
+// ============================
+// FileStore
+// ============================
+
+pub struct FileStore {
+    root_dir: PathBuf,
+}
+
+impl FileStore {
+    pub fn new(root_dir: PathBuf) -> Self {
+        Self { root_dir }
+    }
+
+    pub async fn initialize(&self) -> Result<()> {
+        fs::create_dir_all(&self.root_dir).await?;
+        Ok(())
+    }
+
+    pub async fn reset(&self) -> Result<()> {
+        if self.root_dir.exists() {
+            fs::remove_dir_all(&self.root_dir).await?;
+        }
+        fs::create_dir_all(&self.root_dir).await?;
+        Ok(())
+    }
+
+    // ============================
+    // Bucket operations
+    // ============================
+
+    pub async fn list_buckets(&self) -> Result<Vec<BucketInfo>> {
+        let mut buckets = Vec::new();
+        let mut entries = fs::read_dir(&self.root_dir).await?;
+
+        while let Some(entry) = entries.next_entry().await? {
+            let meta = entry.metadata().await?;
+            if meta.is_dir() {
+                let name = entry.file_name().to_string_lossy().to_string();
+                // Skip hidden dirs like .multipart
+                if name.starts_with('.') {
+                    continue;
+                }
+                let creation_date: DateTime<Utc> = meta
+                    .created()
+                    .unwrap_or(meta.modified().unwrap_or(std::time::SystemTime::UNIX_EPOCH))
+                    .into();
+                buckets.push(BucketInfo {
+                    name,
+                    creation_date,
+                });
+            }
+        }
+
+        buckets.sort_by(|a, b| a.name.cmp(&b.name));
+        Ok(buckets)
+    }
+
+    pub async fn bucket_exists(&self, bucket: &str) -> bool {
+        self.root_dir.join(bucket).is_dir()
+    }
+
+    pub async fn create_bucket(&self, bucket: &str) -> Result<()> {
+        let bucket_path = self.root_dir.join(bucket);
+        fs::create_dir_all(&bucket_path).await?;
+        Ok(())
+    }
+
+    pub async fn delete_bucket(&self, bucket: &str) -> Result<()> {
+        let bucket_path = self.root_dir.join(bucket);
+
+        if !bucket_path.is_dir() {
+            return Err(S3Error::no_such_bucket().into());
+        }
+
+        // Check if bucket is empty (ignore hidden files)
+        let mut entries = fs::read_dir(&bucket_path).await?;
+        while let Some(_entry) = entries.next_entry().await? {
+            return Err(S3Error::bucket_not_empty().into());
+        }
+
+        fs::remove_dir_all(&bucket_path).await?;
+        Ok(())
+    }
+
+    // ============================
+    // Object operations
+    // ============================
+
+    pub async fn put_object(
+        &self,
+        bucket: &str,
+        key: &str,
+        body: Incoming,
+        metadata: HashMap<String, String>,
+    ) -> Result<PutResult> {
+        if !self.bucket_exists(bucket).await {
+            return Err(S3Error::no_such_bucket().into());
+        }
+
+        let object_path = self.object_path(bucket, key);
+        if let Some(parent) = object_path.parent() {
+            fs::create_dir_all(parent).await?;
+        }
+
+        let file = fs::File::create(&object_path).await?;
+        let mut writer = BufWriter::new(file);
+        let mut hasher = Md5::new();
+        let mut total_size: u64 = 0;
+
+        // Stream body frames directly to file
+        let mut body = body;
+        loop {
+            match body.frame().await {
+                Some(Ok(frame)) => {
+                    if let Ok(data) = frame.into_data() {
+                        hasher.update(&data);
+                        total_size += data.len() as u64;
+                        writer.write_all(&data).await?;
+                    }
+                }
+                Some(Err(e)) => {
+                    return Err(anyhow::anyhow!("Body read error: {}", e));
+                }
+                None => break,
+            }
+        }
+
+        writer.flush().await?;
+        drop(writer);
+
+        let md5_hex = format!("{:x}", hasher.finalize());
+
+        // Write MD5 sidecar
+        let md5_path = format!("{}.md5", object_path.display());
+        fs::write(&md5_path, &md5_hex).await?;
+
+        // Write metadata sidecar
+        let metadata_path = format!("{}.metadata.json", object_path.display());
+        let metadata_json = serde_json::to_string_pretty(&metadata)?;
+        fs::write(&metadata_path, metadata_json).await?;
+
+        Ok(PutResult {
+            size: total_size,
+            md5: md5_hex,
+        })
+    }
+
+    pub async fn put_object_bytes(
+        &self,
+        bucket: &str,
+        key: &str,
+        data: &[u8],
+        metadata: HashMap<String, String>,
+    ) -> Result<PutResult> {
+        if !self.bucket_exists(bucket).await {
+            return Err(S3Error::no_such_bucket().into());
+        }
+
+        let object_path = self.object_path(bucket, key);
+        if let Some(parent) = object_path.parent() {
+            fs::create_dir_all(parent).await?;
+        }
+
+        let mut hasher = Md5::new();
+        hasher.update(data);
+        let md5_hex = format!("{:x}", hasher.finalize());
+
+        fs::write(&object_path, data).await?;
+
+        // Write MD5 sidecar
+        let md5_path = format!("{}.md5", object_path.display());
+        fs::write(&md5_path, &md5_hex).await?;
+
+        // Write metadata sidecar
+        let metadata_path = format!("{}.metadata.json", object_path.display());
+        let metadata_json = serde_json::to_string_pretty(&metadata)?;
+        fs::write(&metadata_path, metadata_json).await?;
+
+        Ok(PutResult {
+            size: data.len() as u64,
+            md5: md5_hex,
+        })
+    }
+
+    pub async fn get_object(
+        &self,
+        bucket: &str,
+        key: &str,
+        range: Option<(u64, u64)>,
+    ) -> Result<GetResult> {
+        let object_path = self.object_path(bucket, key);
+
+        if !object_path.exists() {
+            return Err(S3Error::no_such_key().into());
+        }
+
+        let file_meta = fs::metadata(&object_path).await?;
+        let size = file_meta.len();
+        let last_modified: DateTime<Utc> = file_meta.modified()?.into();
+
+        let md5 = self.read_md5(&object_path).await;
+        let metadata = self.read_metadata(&object_path).await;
+
+        let mut file = fs::File::open(&object_path).await?;
+
+        let content_length = if let Some((start, end)) = range {
+            file.seek(std::io::SeekFrom::Start(start)).await?;
+            end - start + 1
+        } else {
+            size
+        };
+
+        Ok(GetResult {
+            key: key.to_string(),
+            size,
+            last_modified,
+            md5,
+            metadata,
+            body: file,
+            content_length,
+        })
+    }
+
+    pub async fn head_object(&self, bucket: &str, key: &str) -> Result<HeadResult> {
+        let object_path = self.object_path(bucket, key);
+
+        if !object_path.exists() {
+            return Err(S3Error::no_such_key().into());
+        }
+
+        // Only stat the file, don't open it
+        let file_meta = fs::metadata(&object_path).await?;
+        let size = file_meta.len();
+        let last_modified: DateTime<Utc> = file_meta.modified()?.into();
+
+        let md5 = self.read_md5(&object_path).await;
+        let metadata = self.read_metadata(&object_path).await;
+
+        Ok(HeadResult {
+            key: key.to_string(),
+            size,
+            last_modified,
+            md5,
+            metadata,
+        })
+    }
+
+    pub async fn delete_object(&self, bucket: &str, key: &str) -> Result<()> {
+        let object_path = self.object_path(bucket, key);
+        let md5_path = format!("{}.md5", object_path.display());
+        let metadata_path = format!("{}.metadata.json", object_path.display());
+
+        // S3 doesn't error if object doesn't exist
+        let _ = fs::remove_file(&object_path).await;
+        let _ = fs::remove_file(&md5_path).await;
+        let _ = fs::remove_file(&metadata_path).await;
+
+        // Clean up empty parent directories up to bucket level
+        let bucket_path = self.root_dir.join(bucket);
+        let mut current = object_path.parent().map(|p| p.to_path_buf());
+        while let Some(dir) = current {
+            if dir == bucket_path {
+                break;
+            }
+            if fs::read_dir(&dir).await.is_ok() {
+                let mut entries = fs::read_dir(&dir).await?;
+                if entries.next_entry().await?.is_none() {
+                    let _ = fs::remove_dir(&dir).await;
+                } else {
+                    break;
+                }
+            }
+            current = dir.parent().map(|p| p.to_path_buf());
+        }
+
+        Ok(())
+    }
+
+    pub async fn copy_object(
+        &self,
+        src_bucket: &str,
+        src_key: &str,
+        dest_bucket: &str,
+        dest_key: &str,
+        metadata_directive: &str,
+        new_metadata: Option<HashMap<String, String>>,
+    ) -> Result<CopyResult> {
+        let src_path = self.object_path(src_bucket, src_key);
+        let dest_path = self.object_path(dest_bucket, dest_key);
+
+        if !src_path.exists() {
+            return Err(S3Error::no_such_key().into());
+        }
+
+        if !self.bucket_exists(dest_bucket).await {
+            return Err(S3Error::no_such_bucket().into());
+        }
+
+        if let Some(parent) = dest_path.parent() {
+            fs::create_dir_all(parent).await?;
+        }
+
+        // Copy object file
+        fs::copy(&src_path, &dest_path).await?;
+
+        // Handle metadata
+        if metadata_directive == "COPY" {
+            let src_meta_path = format!("{}.metadata.json", src_path.display());
+            let dest_meta_path = format!("{}.metadata.json", dest_path.display());
+            let _ = fs::copy(&src_meta_path, &dest_meta_path).await;
+        } else if let Some(meta) = new_metadata {
+            let dest_meta_path = format!("{}.metadata.json", dest_path.display());
+            let json = serde_json::to_string_pretty(&meta)?;
+            fs::write(&dest_meta_path, json).await?;
+        }
+
+        // Copy MD5
+        let src_md5_path = format!("{}.md5", src_path.display());
+        let dest_md5_path = format!("{}.md5", dest_path.display());
+        let _ = fs::copy(&src_md5_path, &dest_md5_path).await;
+
+        let file_meta = fs::metadata(&dest_path).await?;
+        let md5 = self.read_md5(&dest_path).await;
+        let last_modified: DateTime<Utc> = file_meta.modified()?.into();
+
+        Ok(CopyResult {
+            size: file_meta.len(),
+            md5,
+            last_modified,
+        })
+    }
+
+    pub async fn list_objects(
+        &self,
+        bucket: &str,
+        prefix: &str,
+        delimiter: &str,
+        max_keys: usize,
+        continuation_token: Option<&str>,
+    ) -> Result<ListObjectsResult> {
+        let bucket_path = self.root_dir.join(bucket);
+
+        if !bucket_path.is_dir() {
+            return Err(S3Error::no_such_bucket().into());
+        }
+
+        // Collect all object keys recursively
+        let mut keys = Vec::new();
+        self.collect_keys(&bucket_path, &bucket_path, &mut keys)
+            .await?;
+
+        // Apply prefix filter
+        if !prefix.is_empty() {
+            keys.retain(|k| k.starts_with(prefix));
+        }
+
+        keys.sort();
+
+        // Handle continuation token
+        if let Some(token) = continuation_token {
+            if let Some(pos) = keys.iter().position(|k| k.as_str() > token) {
+                keys = keys[pos..].to_vec();
+            } else {
+                keys.clear();
+            }
+        }
+
+        // Handle delimiter and pagination
+        let mut common_prefixes: Vec<String> = Vec::new();
+        let mut common_prefix_set = std::collections::HashSet::new();
+        let mut contents: Vec<ListObjectEntry> = Vec::new();
+        let mut is_truncated = false;
+
+        for key in &keys {
+            if !delimiter.is_empty() {
+                let remaining = &key[prefix.len()..];
+                if let Some(delim_idx) = remaining.find(delimiter) {
+                    let cp = format!(
+                        "{}{}",
+                        prefix,
+                        &remaining[..delim_idx + delimiter.len()]
+                    );
+                    if common_prefix_set.insert(cp.clone()) {
+                        common_prefixes.push(cp);
+                    }
+                    continue;
+                }
+            }
+
+            if contents.len() >= max_keys {
+                is_truncated = true;
+                break;
+            }
+
+            let object_path = self.object_path(bucket, key);
+            if let Ok(meta) = fs::metadata(&object_path).await {
+                let md5 = self.read_md5(&object_path).await;
+                let last_modified: DateTime<Utc> = meta.modified().unwrap_or(std::time::SystemTime::UNIX_EPOCH).into();
+                contents.push(ListObjectEntry {
+                    key: key.clone(),
+                    size: meta.len(),
+                    last_modified,
+                    md5,
+                });
+            }
+        }
+
+        let next_continuation_token = if is_truncated {
+            contents.last().map(|e| e.key.clone())
+        } else {
+            None
+        };
+
+        common_prefixes.sort();
+
+        Ok(ListObjectsResult {
+            contents,
+            common_prefixes,
+            is_truncated,
+            next_continuation_token,
+            prefix: prefix.to_string(),
+            delimiter: delimiter.to_string(),
+            max_keys,
+        })
+    }
+
+    // ============================
+    // Multipart operations
+    // ============================
+
+    fn multipart_dir(&self) -> PathBuf {
+        self.root_dir.join(".multipart")
+    }
+
+    pub async fn initiate_multipart(
+        &self,
+        bucket: &str,
+        key: &str,
+        metadata: HashMap<String, String>,
+    ) -> Result<String> {
+        let upload_id = Uuid::new_v4().to_string().replace('-', "");
+        let upload_dir = self.multipart_dir().join(&upload_id);
+        fs::create_dir_all(&upload_dir).await?;
+
+        let meta = MultipartMetadata {
+            upload_id: upload_id.clone(),
+            bucket: bucket.to_string(),
+            key: key.to_string(),
+            initiated: Utc::now().to_rfc3339(),
+            metadata,
+            parts: Vec::new(),
+        };
+
+        let meta_path = upload_dir.join("metadata.json");
+        let json = serde_json::to_string_pretty(&meta)?;
+        fs::write(&meta_path, json).await?;
+
+        Ok(upload_id)
+    }
+
+    pub async fn upload_part(
+        &self,
+        upload_id: &str,
+        part_number: u32,
+        body: Incoming,
+    ) -> Result<(String, u64)> {
+        let upload_dir = self.multipart_dir().join(upload_id);
+        if !upload_dir.is_dir() {
+            return Err(S3Error::no_such_upload().into());
+        }
+
+        let part_path = upload_dir.join(format!("part-{}", part_number));
+        let file = fs::File::create(&part_path).await?;
+        let mut writer = BufWriter::new(file);
+        let mut hasher = Md5::new();
+        let mut size: u64 = 0;
+
+        let mut body = body;
+        loop {
+            match body.frame().await {
+                Some(Ok(frame)) => {
+                    if let Ok(data) = frame.into_data() {
+                        hasher.update(&data);
+                        size += data.len() as u64;
+                        writer.write_all(&data).await?;
+                    }
+                }
+                Some(Err(e)) => {
+                    return Err(anyhow::anyhow!("Body read error: {}", e));
+                }
+                None => break,
+            }
+        }
+
+        writer.flush().await?;
+        drop(writer);
+
+        let etag = format!("{:x}", hasher.finalize());
+
+        // Update metadata
+        self.update_multipart_metadata(upload_id, part_number, &etag, size)
+            .await?;
+
+        Ok((etag, size))
+    }
+
+    async fn update_multipart_metadata(
+        &self,
+        upload_id: &str,
+        part_number: u32,
+        etag: &str,
+        size: u64,
+    ) -> Result<()> {
+        let meta_path = self.multipart_dir().join(upload_id).join("metadata.json");
+        let content = fs::read_to_string(&meta_path).await?;
+        let mut meta: MultipartMetadata = serde_json::from_str(&content)?;
+
+        // Remove existing part with same number
+        meta.parts.retain(|p| p.part_number != part_number);
+
+        meta.parts.push(PartMetadata {
+            part_number,
+            etag: etag.to_string(),
+            size,
+            last_modified: Utc::now().to_rfc3339(),
+        });
+
+        meta.parts.sort_by_key(|p| p.part_number);
+
+        let json = serde_json::to_string_pretty(&meta)?;
+        fs::write(&meta_path, json).await?;
+
+        Ok(())
+    }
+
+    pub async fn complete_multipart(
+        &self,
+        upload_id: &str,
+        parts: &[(u32, String)],
+    ) -> Result<CompleteMultipartResult> {
+        let upload_dir = self.multipart_dir().join(upload_id);
+        if !upload_dir.is_dir() {
+            return Err(S3Error::no_such_upload().into());
+        }
+
+        // Read metadata to get bucket/key
+        let meta_path = upload_dir.join("metadata.json");
+        let content = fs::read_to_string(&meta_path).await?;
+        let meta: MultipartMetadata = serde_json::from_str(&content)?;
+
+        let object_path = self.object_path(&meta.bucket, &meta.key);
+        if let Some(parent) = object_path.parent() {
+            fs::create_dir_all(parent).await?;
+        }
+
+        // Concatenate parts into final object, stream each part
+        let dest_file = fs::File::create(&object_path).await?;
+        let mut writer = BufWriter::new(dest_file);
+        let mut hasher = Md5::new();
+        let mut total_size: u64 = 0;
+
+        for (part_number, _etag) in parts {
+            let part_path = upload_dir.join(format!("part-{}", part_number));
+            if !part_path.exists() {
+                return Err(anyhow::anyhow!("Part {} not found", part_number));
+            }
+
+            let mut part_file = fs::File::open(&part_path).await?;
+            let mut buf = vec![0u8; 64 * 1024]; // 64KB buffer
+            loop {
+                let n = part_file.read(&mut buf).await?;
+                if n == 0 {
+                    break;
+                }
+                hasher.update(&buf[..n]);
+                writer.write_all(&buf[..n]).await?;
+                total_size += n as u64;
+            }
+        }
+
+        writer.flush().await?;
+        drop(writer);
+
+        let etag = format!("{:x}", hasher.finalize());
+
+        // Write MD5 sidecar
+        let md5_path = format!("{}.md5", object_path.display());
+        fs::write(&md5_path, &etag).await?;
+
+        // Write metadata sidecar
+        let metadata_path = format!("{}.metadata.json", object_path.display());
+        let metadata_json = serde_json::to_string_pretty(&meta.metadata)?;
+        fs::write(&metadata_path, metadata_json).await?;
+
+        // Clean up multipart directory
+        let _ = fs::remove_dir_all(&upload_dir).await;
+
+        Ok(CompleteMultipartResult {
+            etag,
+            size: total_size,
+        })
+    }
+
+    pub async fn abort_multipart(&self, upload_id: &str) -> Result<()> {
+        let upload_dir = self.multipart_dir().join(upload_id);
+        if !upload_dir.is_dir() {
+            return Err(S3Error::no_such_upload().into());
+        }
+        fs::remove_dir_all(&upload_dir).await?;
+        Ok(())
+    }
+
+    pub async fn list_multipart_uploads(
+        &self,
+        bucket: &str,
+    ) -> Result<Vec<MultipartUploadInfo>> {
+        let multipart_dir = self.multipart_dir();
+        if !multipart_dir.is_dir() {
+            return Ok(Vec::new());
+        }
+
+        let mut uploads = Vec::new();
+        let mut entries = fs::read_dir(&multipart_dir).await?;
+
+        while let Some(entry) = entries.next_entry().await? {
+            if !entry.metadata().await?.is_dir() {
+                continue;
+            }
+
+            let meta_path = entry.path().join("metadata.json");
+            if let Ok(content) = fs::read_to_string(&meta_path).await {
+                if let Ok(meta) = serde_json::from_str::<MultipartMetadata>(&content) {
+                    if meta.bucket == bucket {
+                        let initiated = DateTime::parse_from_rfc3339(&meta.initiated)
+                            .map(|dt| dt.with_timezone(&Utc))
+                            .unwrap_or_else(|_| Utc::now());
+
+                        uploads.push(MultipartUploadInfo {
+                            upload_id: meta.upload_id,
+                            bucket: meta.bucket,
+                            key: meta.key,
+                            initiated,
+                        });
+                    }
+                }
+            }
+        }
+
+        Ok(uploads)
+    }
+
+    // ============================
+    // Helpers
+    // ============================
+
+    fn object_path(&self, bucket: &str, key: &str) -> PathBuf {
+        let encoded = encode_key(key);
+        self.root_dir
+            .join(bucket)
+            .join(format!("{}._S3_object", encoded))
+    }
+
+    async fn read_md5(&self, object_path: &Path) -> String {
+        let md5_path = format!("{}.md5", object_path.display());
+        match fs::read_to_string(&md5_path).await {
+            Ok(s) => s.trim().to_string(),
+            Err(_) => {
+                // Calculate MD5 if sidecar missing
+                match self.calculate_md5(object_path).await {
+                    Ok(hash) => {
+                        let _ = fs::write(&md5_path, &hash).await;
+                        hash
+                    }
+                    Err(_) => String::new(),
+                }
+            }
+        }
+    }
+
+    async fn calculate_md5(&self, path: &Path) -> Result<String> {
+        let mut file = fs::File::open(path).await?;
+        let mut hasher = Md5::new();
+        let mut buf = vec![0u8; 64 * 1024];
+        loop {
+            let n = file.read(&mut buf).await?;
+            if n == 0 {
+                break;
+            }
+            hasher.update(&buf[..n]);
+        }
+        Ok(format!("{:x}", hasher.finalize()))
+    }
+
+    async fn read_metadata(&self, object_path: &Path) -> HashMap<String, String> {
+        let meta_path = format!("{}.metadata.json", object_path.display());
+        match fs::read_to_string(&meta_path).await {
+            Ok(s) => serde_json::from_str(&s).unwrap_or_default(),
+            Err(_) => HashMap::new(),
+        }
+    }
+
+    fn collect_keys<'a>(
+        &'a self,
+        bucket_path: &'a Path,
+        dir: &'a Path,
+        keys: &'a mut Vec<String>,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<()>> + Send + 'a>> {
+        Box::pin(async move {
+            let mut entries = match fs::read_dir(dir).await {
+                Ok(e) => e,
+                Err(_) => return Ok(()),
+            };
+
+            while let Some(entry) = entries.next_entry().await? {
+                let meta = entry.metadata().await?;
+                let name = entry.file_name().to_string_lossy().to_string();
+
+                if meta.is_dir() {
+                    self.collect_keys(bucket_path, &entry.path(), keys).await?;
+                } else if name.ends_with("._S3_object")
+                    && !name.ends_with(".metadata.json")
+                    && !name.ends_with(".md5")
+                {
+                    let relative = entry
+                        .path()
+                        .strip_prefix(bucket_path)
+                        .unwrap_or(Path::new(""))
+                        .to_string_lossy()
+                        .to_string();
+                    let key = decode_key(relative.trim_end_matches("._S3_object"));
+                    keys.push(key);
+                }
+            }
+
+            Ok(())
+        })
+    }
+}
+
+// ============================
+// Key encoding (identity on Linux)
+// ============================
+
+fn encode_key(key: &str) -> String {
+    if cfg!(windows) {
+        key.chars()
+            .map(|c| match c {
+                '<' | '>' | ':' | '"' | '\\' | '|' | '?' | '*' => {
+                    format!("&{:02x}", c as u32)
+                }
+                _ => c.to_string(),
+            })
+            .collect()
+    } else {
+        key.to_string()
+    }
+}
+
+fn decode_key(encoded: &str) -> String {
+    if cfg!(windows) {
+        let mut result = String::new();
+        let mut chars = encoded.chars();
+        while let Some(c) = chars.next() {
+            if c == '&' {
+                let hex: String = chars.by_ref().take(2).collect();
+                if let Ok(byte) = u8::from_str_radix(&hex, 16) {
+                    result.push(byte as char);
+                } else {
+                    result.push('&');
+                    result.push_str(&hex);
+                }
+            } else {
+                result.push(c);
+            }
+        }
+        result
+    } else {
+        encoded.to_string()
+    }
+}
--- a/rust/src/xml_response.rs
+++ b/rust/src/xml_response.rs
@@ -0,0 +1,220 @@
+use crate::storage::{BucketInfo, ListObjectsResult, MultipartUploadInfo};
+
+const XML_DECL: &str = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
+const S3_NS: &str = "http://s3.amazonaws.com/doc/2006-03-01/";
+
+fn xml_escape(s: &str) -> String {
+    s.replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+        .replace('"', "&quot;")
+        .replace('\'', "&apos;")
+}
+
+pub fn list_buckets_xml(buckets: &[BucketInfo]) -> String {
+    let mut xml = format!(
+        "{}\n<ListAllMyBucketsResult xmlns=\"{}\">\
+         <Owner><ID>123456789000</ID><DisplayName>S3rver</DisplayName></Owner>\
+         <Buckets>",
+        XML_DECL, S3_NS
+    );
+
+    for b in buckets {
+        xml.push_str(&format!(
+            "<Bucket><Name>{}</Name><CreationDate>{}</CreationDate></Bucket>",
+            xml_escape(&b.name),
+            b.creation_date.to_rfc3339()
+        ));
+    }
+
+    xml.push_str("</Buckets></ListAllMyBucketsResult>");
+    xml
+}
+
+pub fn list_objects_v1_xml(bucket: &str, result: &ListObjectsResult) -> String {
+    let mut xml = format!(
+        "{}\n<ListBucketResult xmlns=\"{}\">\
+         <Name>{}</Name>\
+         <Prefix>{}</Prefix>\
+         <MaxKeys>{}</MaxKeys>\
+         <IsTruncated>{}</IsTruncated>",
+        XML_DECL,
+        S3_NS,
+        xml_escape(bucket),
+        xml_escape(&result.prefix),
+        result.max_keys,
+        result.is_truncated
+    );
+
+    if !result.delimiter.is_empty() {
+        xml.push_str(&format!("<Delimiter>{}</Delimiter>", xml_escape(&result.delimiter)));
+    }
+
+    for entry in &result.contents {
+        xml.push_str(&format!(
+            "<Contents>\
+             <Key>{}</Key>\
+             <LastModified>{}</LastModified>\
+             <ETag>\"{}\"</ETag>\
+             <Size>{}</Size>\
+             <StorageClass>STANDARD</StorageClass>\
+             </Contents>",
+            xml_escape(&entry.key),
+            entry.last_modified.to_rfc3339(),
+            xml_escape(&entry.md5),
+            entry.size
+        ));
+    }
+
+    for cp in &result.common_prefixes {
+        xml.push_str(&format!(
+            "<CommonPrefixes><Prefix>{}</Prefix></CommonPrefixes>",
+            xml_escape(cp)
+        ));
+    }
+
+    xml.push_str("</ListBucketResult>");
+    xml
+}
+
+pub fn list_objects_v2_xml(bucket: &str, result: &ListObjectsResult) -> String {
+    let mut xml = format!(
+        "{}\n<ListBucketResult xmlns=\"{}\">\
+         <Name>{}</Name>\
+         <Prefix>{}</Prefix>\
+         <MaxKeys>{}</MaxKeys>\
+         <KeyCount>{}</KeyCount>\
+         <IsTruncated>{}</IsTruncated>",
+        XML_DECL,
+        S3_NS,
+        xml_escape(bucket),
+        xml_escape(&result.prefix),
+        result.max_keys,
+        result.contents.len(),
+        result.is_truncated
+    );
+
+    if !result.delimiter.is_empty() {
+        xml.push_str(&format!("<Delimiter>{}</Delimiter>", xml_escape(&result.delimiter)));
+    }
+
+    if let Some(ref token) = result.next_continuation_token {
+        xml.push_str(&format!(
+            "<NextContinuationToken>{}</NextContinuationToken>",
+            xml_escape(token)
+        ));
+    }
+
+    for entry in &result.contents {
+        xml.push_str(&format!(
+            "<Contents>\
+             <Key>{}</Key>\
+             <LastModified>{}</LastModified>\
+             <ETag>\"{}\"</ETag>\
+             <Size>{}</Size>\
+             <StorageClass>STANDARD</StorageClass>\
+             </Contents>",
+            xml_escape(&entry.key),
+            entry.last_modified.to_rfc3339(),
+            xml_escape(&entry.md5),
+            entry.size
+        ));
+    }
+
+    for cp in &result.common_prefixes {
+        xml.push_str(&format!(
+            "<CommonPrefixes><Prefix>{}</Prefix></CommonPrefixes>",
+            xml_escape(cp)
+        ));
+    }
+
+    xml.push_str("</ListBucketResult>");
+    xml
+}
+
+pub fn error_xml(code: &str, message: &str) -> String {
+    format!(
+        "{}\n<Error><Code>{}</Code><Message>{}</Message></Error>",
+        XML_DECL,
+        xml_escape(code),
+        xml_escape(message)
+    )
+}
+
+pub fn copy_object_result_xml(etag: &str, last_modified: &str) -> String {
+    format!(
+        "{}\n<CopyObjectResult>\
+         <LastModified>{}</LastModified>\
+         <ETag>\"{}\"</ETag>\
+         </CopyObjectResult>",
+        XML_DECL,
+        xml_escape(last_modified),
+        xml_escape(etag)
+    )
+}
+
+pub fn initiate_multipart_xml(bucket: &str, key: &str, upload_id: &str) -> String {
+    format!(
+        "{}\n<InitiateMultipartUploadResult xmlns=\"{}\">\
+         <Bucket>{}</Bucket>\
+         <Key>{}</Key>\
+         <UploadId>{}</UploadId>\
+         </InitiateMultipartUploadResult>",
+        XML_DECL,
+        S3_NS,
+        xml_escape(bucket),
+        xml_escape(key),
+        xml_escape(upload_id)
+    )
+}
+
+pub fn complete_multipart_xml(bucket: &str, key: &str, etag: &str) -> String {
+    format!(
+        "{}\n<CompleteMultipartUploadResult xmlns=\"{}\">\
+         <Location>/{}/{}</Location>\
+         <Bucket>{}</Bucket>\
+         <Key>{}</Key>\
+         <ETag>\"{}\"</ETag>\
+         </CompleteMultipartUploadResult>",
+        XML_DECL,
+        S3_NS,
+        xml_escape(bucket),
+        xml_escape(key),
+        xml_escape(bucket),
+        xml_escape(key),
+        xml_escape(etag)
+    )
+}
+
+pub fn list_multipart_uploads_xml(bucket: &str, uploads: &[MultipartUploadInfo]) -> String {
+    let mut xml = format!(
+        "{}\n<ListMultipartUploadsResult xmlns=\"{}\">\
+         <Bucket>{}</Bucket>\
+         <KeyMarker></KeyMarker>\
+         <UploadIdMarker></UploadIdMarker>\
+         <MaxUploads>1000</MaxUploads>\
+         <IsTruncated>false</IsTruncated>",
+        XML_DECL,
+        S3_NS,
+        xml_escape(bucket)
+    );
+
+    for u in uploads {
+        xml.push_str(&format!(
+            "<Upload>\
+             <Key>{}</Key>\
+             <UploadId>{}</UploadId>\
+             <Initiator><ID>S3RVER</ID><DisplayName>S3RVER</DisplayName></Initiator>\
+             <Owner><ID>S3RVER</ID><DisplayName>S3RVER</DisplayName></Owner>\
+             <StorageClass>STANDARD</StorageClass>\
+             <Initiated>{}</Initiated>\
+             </Upload>",
+            xml_escape(&u.key),
+            xml_escape(&u.upload_id),
+            u.initiated.to_rfc3339()
+        ));
+    }
+
+    xml.push_str("</ListMultipartUploadsResult>");
+    xml
+}
--- a/test/test.aws-sdk.node.ts
+++ b/test/test.aws-sdk.node.ts
@@ -18,9 +18,13 @@ async function streamToString(stream: Readable): Promise<string> {

 tap.test('should start the S3 server and configure client', async () => {
  testSmarts3Instance = await smarts3.Smarts3.createAndStart({
+    server: {
      port: 3337,
-    cleanSlate: true,
      silent: true,
+    },
+    storage: {
+      cleanSlate: true,
+    },
  });

  const descriptor = await testSmarts3Instance.getS3Descriptor();
--- a/test/test.ts
+++ b/test/test.ts
@@ -7,8 +7,12 @@ let testSmarts3Instance: smarts3.Smarts3;

 tap.test('should create a smarts3 instance and run it', async (toolsArg) => {
  testSmarts3Instance = await smarts3.Smarts3.createAndStart({
+    server: {
      port: 3333,
+    },
+    storage: {
      cleanSlate: true,
+    },
  });
  console.log(`Let the instance run for 2 seconds`);
  await toolsArg.delayFor(2000);
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -3,6 +3,6 @@
 */
 export const commitinfo = {
  name: '@push.rocks/smarts3',
-  version: '2.3.0',
+  version: '5.1.1',
  description: 'A Node.js TypeScript package to create a local S3 endpoint for simulating AWS S3 operations using mapped local directories for development and testing purposes.'
 }
--- a/ts/classes/context.ts
+++ b/ts/classes/context.ts
@@ -1,114 +0,0 @@
-import * as plugins from '../plugins.js';
-import { S3Error } from './s3-error.js';
-import { createXml } from '../utils/xml.utils.js';
-import type { FilesystemStore } from './filesystem-store.js';
-import type { Readable } from 'stream';
-
-/**
- * S3 request context with helper methods
- */
-export class S3Context {
-  public method: string;
-  public url: URL;
-  public headers: plugins.http.IncomingHttpHeaders;
-  public params: Record<string, string> = {};
-  public query: Record<string, string> = {};
-  public store: FilesystemStore;
-
-  private req: plugins.http.IncomingMessage;
-  private res: plugins.http.ServerResponse;
-  private statusCode: number = 200;
-  private responseHeaders: Record<string, string> = {};
-
-  constructor(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    store: FilesystemStore
-  ) {
-    this.req = req;
-    this.res = res;
-    this.store = store;
-    this.method = req.method || 'GET';
-    this.headers = req.headers;
-
-    // Parse URL and query string
-    const fullUrl = `http://${req.headers.host || 'localhost'}${req.url || '/'}`;
-    this.url = new URL(fullUrl);
-
-    // Parse query string into object
-    this.url.searchParams.forEach((value, key) => {
-      this.query[key] = value;
-    });
-  }
-
-  /**
-   * Set response status code
-   */
-  public status(code: number): this {
-    this.statusCode = code;
-    return this;
-  }
-
-  /**
-   * Set response header
-   */
-  public setHeader(name: string, value: string | number): this {
-    this.responseHeaders[name] = value.toString();
-    return this;
-  }
-
-  /**
-   * Send response body (string, Buffer, or Stream)
-   */
-  public async send(body: string | Buffer | Readable | NodeJS.ReadableStream): Promise<void> {
-    // Write status and headers
-    this.res.writeHead(this.statusCode, this.responseHeaders);
-
-    // Handle different body types
-    if (typeof body === 'string' || body instanceof Buffer) {
-      this.res.end(body);
-    } else if (body && typeof (body as any).pipe === 'function') {
-      // It's a stream
-      (body as Readable).pipe(this.res);
-    } else {
-      this.res.end();
-    }
-  }
-
-  /**
-   * Send XML response
-   */
-  public async sendXML(obj: any): Promise<void> {
-    const xml = createXml(obj, { format: true });
-    this.setHeader('Content-Type', 'application/xml');
-    this.setHeader('Content-Length', Buffer.byteLength(xml));
-    await this.send(xml);
-  }
-
-  /**
-   * Throw an S3 error
-   */
-  public throw(code: string, message: string, detail?: Record<string, any>): never {
-    throw new S3Error(code, message, detail);
-  }
-
-  /**
-   * Read and parse request body as string
-   */
-  public async readBody(): Promise<string> {
-    return new Promise((resolve, reject) => {
-      const chunks: Buffer[] = [];
-
-      this.req.on('data', (chunk) => chunks.push(chunk));
-      this.req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-      this.req.on('error', reject);
-    });
-  }
-
-  /**
-   * Get the request stream (for streaming uploads)
-   */
-  public getRequestStream(): NodeJS.ReadableStream {
-    return this.req;
-  }
-}
--- a/ts/classes/filesystem-store.ts
+++ b/ts/classes/filesystem-store.ts
@@ -1,495 +0,0 @@
-import * as plugins from '../plugins.js';
-import { S3Error } from './s3-error.js';
-import type { Readable } from 'stream';
-
-export interface IS3Bucket {
-  name: string;
-  creationDate: Date;
-}
-
-export interface IS3Object {
-  key: string;
-  size: number;
-  lastModified: Date;
-  md5: string;
-  metadata: Record<string, string>;
-  content?: Readable;
-}
-
-export interface IListObjectsOptions {
-  prefix?: string;
-  delimiter?: string;
-  maxKeys?: number;
-  continuationToken?: string;
-}
-
-export interface IListObjectsResult {
-  contents: IS3Object[];
-  commonPrefixes: string[];
-  isTruncated: boolean;
-  nextContinuationToken?: string;
-  prefix: string;
-  delimiter: string;
-  maxKeys: number;
-}
-
-export interface IRangeOptions {
-  start: number;
-  end: number;
-}
-
-/**
- * Filesystem-backed storage for S3 objects
- */
-export class FilesystemStore {
-  constructor(private rootDir: string) {}
-
-  /**
-   * Initialize store (ensure root directory exists)
-   */
-  public async initialize(): Promise<void> {
-    await plugins.fs.promises.mkdir(this.rootDir, { recursive: true });
-  }
-
-  /**
-   * Reset store (delete all buckets)
-   */
-  public async reset(): Promise<void> {
-    await plugins.smartfile.fs.ensureEmptyDir(this.rootDir);
-  }
-
-  // ============================
-  // BUCKET OPERATIONS
-  // ============================
-
-  /**
-   * List all buckets
-   */
-  public async listBuckets(): Promise<IS3Bucket[]> {
-    const dirs = await plugins.smartfile.fs.listFolders(this.rootDir);
-    const buckets: IS3Bucket[] = [];
-
-    for (const dir of dirs) {
-      const bucketPath = plugins.path.join(this.rootDir, dir);
-      const stats = await plugins.smartfile.fs.stat(bucketPath);
-
-      buckets.push({
-        name: dir,
-        creationDate: stats.birthtime,
-      });
-    }
-
-    return buckets.sort((a, b) => a.name.localeCompare(b.name));
-  }
-
-  /**
-   * Check if bucket exists
-   */
-  public async bucketExists(bucket: string): Promise<boolean> {
-    const bucketPath = this.getBucketPath(bucket);
-    return plugins.smartfile.fs.isDirectory(bucketPath);
-  }
-
-  /**
-   * Create bucket
-   */
-  public async createBucket(bucket: string): Promise<void> {
-    const bucketPath = this.getBucketPath(bucket);
-    await plugins.fs.promises.mkdir(bucketPath, { recursive: true });
-  }
-
-  /**
-   * Delete bucket (must be empty)
-   */
-  public async deleteBucket(bucket: string): Promise<void> {
-    const bucketPath = this.getBucketPath(bucket);
-
-    // Check if bucket exists
-    if (!(await this.bucketExists(bucket))) {
-      throw new S3Error('NoSuchBucket', 'The specified bucket does not exist');
-    }
-
-    // Check if bucket is empty
-    const files = await plugins.smartfile.fs.listFileTree(bucketPath, '**/*');
-    if (files.length > 0) {
-      throw new S3Error('BucketNotEmpty', 'The bucket you tried to delete is not empty');
-    }
-
-    await plugins.smartfile.fs.remove(bucketPath);
-  }
-
-  // ============================
-  // OBJECT OPERATIONS
-  // ============================
-
-  /**
-   * List objects in bucket
-   */
-  public async listObjects(
-    bucket: string,
-    options: IListObjectsOptions = {}
-  ): Promise<IListObjectsResult> {
-    const bucketPath = this.getBucketPath(bucket);
-
-    if (!(await this.bucketExists(bucket))) {
-      throw new S3Error('NoSuchBucket', 'The specified bucket does not exist');
-    }
-
-    const {
-      prefix = '',
-      delimiter = '',
-      maxKeys = 1000,
-      continuationToken,
-    } = options;
-
-    // List all object files
-    const objectPattern = '**/*._S3_object';
-    const objectFiles = await plugins.smartfile.fs.listFileTree(bucketPath, objectPattern);
-
-    // Convert file paths to keys
-    let keys = objectFiles.map((filePath) => {
-      const relativePath = plugins.path.relative(bucketPath, filePath);
-      const key = this.decodeKey(relativePath.replace(/\._S3_object$/, ''));
-      return key;
-    });
-
-    // Apply prefix filter
-    if (prefix) {
-      keys = keys.filter((key) => key.startsWith(prefix));
-    }
-
-    // Sort keys
-    keys = keys.sort();
-
-    // Handle continuation token (simple implementation using key name)
-    if (continuationToken) {
-      const startIndex = keys.findIndex((key) => key > continuationToken);
-      if (startIndex > 0) {
-        keys = keys.slice(startIndex);
-      }
-    }
-
-    // Handle delimiter (common prefixes)
-    const commonPrefixes: Set<string> = new Set();
-    const contents: IS3Object[] = [];
-
-    for (const key of keys) {
-      if (delimiter) {
-        // Find first delimiter after prefix
-        const remainingKey = key.slice(prefix.length);
-        const delimiterIndex = remainingKey.indexOf(delimiter);
-
-        if (delimiterIndex !== -1) {
-          // This key has a delimiter, add to common prefixes
-          const commonPrefix = prefix + remainingKey.slice(0, delimiterIndex + delimiter.length);
-          commonPrefixes.add(commonPrefix);
-          continue;
-        }
-      }
-
-      // Add to contents (limited by maxKeys)
-      if (contents.length >= maxKeys) {
-        break;
-      }
-
-      try {
-        const objectInfo = await this.getObjectInfo(bucket, key);
-        contents.push(objectInfo);
-      } catch (err) {
-        // Skip if object no longer exists
-        continue;
-      }
-    }
-
-    const isTruncated = keys.length > contents.length + commonPrefixes.size;
-    const nextContinuationToken = isTruncated
-      ? contents[contents.length - 1]?.key
-      : undefined;
-
-    return {
-      contents,
-      commonPrefixes: Array.from(commonPrefixes).sort(),
-      isTruncated,
-      nextContinuationToken,
-      prefix,
-      delimiter,
-      maxKeys,
-    };
-  }
-
-  /**
-   * Get object info (without content)
-   */
-  private async getObjectInfo(bucket: string, key: string): Promise<IS3Object> {
-    const objectPath = this.getObjectPath(bucket, key);
-    const metadataPath = `${objectPath}.metadata.json`;
-    const md5Path = `${objectPath}.md5`;
-
-    const [stats, metadata, md5] = await Promise.all([
-      plugins.smartfile.fs.stat(objectPath),
-      this.readMetadata(metadataPath),
-      this.readMD5(objectPath, md5Path),
-    ]);
-
-    return {
-      key,
-      size: stats.size,
-      lastModified: stats.mtime,
-      md5,
-      metadata,
-    };
-  }
-
-  /**
-   * Check if object exists
-   */
-  public async objectExists(bucket: string, key: string): Promise<boolean> {
-    const objectPath = this.getObjectPath(bucket, key);
-    return plugins.smartfile.fs.fileExists(objectPath);
-  }
-
-  /**
-   * Put object (upload with streaming)
-   */
-  public async putObject(
-    bucket: string,
-    key: string,
-    stream: NodeJS.ReadableStream,
-    metadata: Record<string, string> = {}
-  ): Promise<{ size: number; md5: string }> {
-    const objectPath = this.getObjectPath(bucket, key);
-
-    // Ensure bucket exists
-    if (!(await this.bucketExists(bucket))) {
-      throw new S3Error('NoSuchBucket', 'The specified bucket does not exist');
-    }
-
-    // Ensure parent directory exists
-    await plugins.fs.promises.mkdir(plugins.path.dirname(objectPath), { recursive: true });
-
-    // Write with MD5 calculation
-    const result = await this.writeStreamWithMD5(stream, objectPath);
-
-    // Save metadata
-    const metadataPath = `${objectPath}.metadata.json`;
-    await plugins.fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
-
-    return result;
-  }
-
-  /**
-   * Get object (download with streaming)
-   */
-  public async getObject(
-    bucket: string,
-    key: string,
-    range?: IRangeOptions
-  ): Promise<IS3Object> {
-    const objectPath = this.getObjectPath(bucket, key);
-
-    if (!(await this.objectExists(bucket, key))) {
-      throw new S3Error('NoSuchKey', 'The specified key does not exist');
-    }
-
-    const info = await this.getObjectInfo(bucket, key);
-
-    // Create read stream with optional range (using native fs for range support)
-    const stream = range
-      ? plugins.fs.createReadStream(objectPath, { start: range.start, end: range.end })
-      : plugins.fs.createReadStream(objectPath);
-
-    return {
-      ...info,
-      content: stream,
-    };
-  }
-
-  /**
-   * Delete object
-   */
-  public async deleteObject(bucket: string, key: string): Promise<void> {
-    const objectPath = this.getObjectPath(bucket, key);
-    const metadataPath = `${objectPath}.metadata.json`;
-    const md5Path = `${objectPath}.md5`;
-
-    // S3 doesn't throw error if object doesn't exist
-    await Promise.all([
-      plugins.smartfile.fs.remove(objectPath).catch(() => {}),
-      plugins.smartfile.fs.remove(metadataPath).catch(() => {}),
-      plugins.smartfile.fs.remove(md5Path).catch(() => {}),
-    ]);
-  }
-
-  /**
-   * Copy object
-   */
-  public async copyObject(
-    srcBucket: string,
-    srcKey: string,
-    destBucket: string,
-    destKey: string,
-    metadataDirective: 'COPY' | 'REPLACE' = 'COPY',
-    newMetadata?: Record<string, string>
-  ): Promise<{ size: number; md5: string }> {
-    const srcObjectPath = this.getObjectPath(srcBucket, srcKey);
-    const destObjectPath = this.getObjectPath(destBucket, destKey);
-
-    // Check source exists
-    if (!(await this.objectExists(srcBucket, srcKey))) {
-      throw new S3Error('NoSuchKey', 'The specified key does not exist');
-    }
-
-    // Ensure dest bucket exists
-    if (!(await this.bucketExists(destBucket))) {
-      throw new S3Error('NoSuchBucket', 'The specified bucket does not exist');
-    }
-
-    // Ensure parent directory exists
-    await plugins.fs.promises.mkdir(plugins.path.dirname(destObjectPath), { recursive: true });
-
-    // Copy object file
-    await plugins.smartfile.fs.copy(srcObjectPath, destObjectPath);
-
-    // Handle metadata
-    if (metadataDirective === 'COPY') {
-      // Copy metadata
-      const srcMetadataPath = `${srcObjectPath}.metadata.json`;
-      const destMetadataPath = `${destObjectPath}.metadata.json`;
-      await plugins.smartfile.fs.copy(srcMetadataPath, destMetadataPath).catch(() => {});
-    } else if (newMetadata) {
-      // Replace with new metadata
-      const destMetadataPath = `${destObjectPath}.metadata.json`;
-      await plugins.fs.promises.writeFile(destMetadataPath, JSON.stringify(newMetadata, null, 2));
-    }
-
-    // Copy MD5
-    const srcMD5Path = `${srcObjectPath}.md5`;
-    const destMD5Path = `${destObjectPath}.md5`;
-    await plugins.smartfile.fs.copy(srcMD5Path, destMD5Path).catch(() => {});
-
-    // Get result info
-    const stats = await plugins.smartfile.fs.stat(destObjectPath);
-    const md5 = await this.readMD5(destObjectPath, destMD5Path);
-
-    return { size: stats.size, md5 };
-  }
-
-  // ============================
-  // HELPER METHODS
-  // ============================
-
-  /**
-   * Get bucket directory path
-   */
-  private getBucketPath(bucket: string): string {
-    return plugins.path.join(this.rootDir, bucket);
-  }
-
-  /**
-   * Get object file path
-   */
-  private getObjectPath(bucket: string, key: string): string {
-    return plugins.path.join(
-      this.rootDir,
-      bucket,
-      this.encodeKey(key) + '._S3_object'
-    );
-  }
-
-  /**
-   * Encode key for Windows compatibility
-   */
-  private encodeKey(key: string): string {
-    if (process.platform === 'win32') {
-      // Replace invalid Windows filename chars with hex encoding
-      return key.replace(/[<>:"\\|?*]/g, (ch) =>
-        '&' + Buffer.from(ch, 'utf8').toString('hex')
-      );
-    }
-    return key;
-  }
-
-  /**
-   * Decode key from filesystem path
-   */
-  private decodeKey(encodedKey: string): string {
-    if (process.platform === 'win32') {
-      // Decode hex-encoded chars
-      return encodedKey.replace(/&([0-9a-f]{2})/gi, (_, hex) =>
-        Buffer.from(hex, 'hex').toString('utf8')
-      );
-    }
-    return encodedKey;
-  }
-
-  /**
-   * Write stream to file with MD5 calculation
-   */
-  private async writeStreamWithMD5(
-    input: NodeJS.ReadableStream,
-    destPath: string
-  ): Promise<{ size: number; md5: string }> {
-    const hash = plugins.crypto.createHash('md5');
-    let totalSize = 0;
-
-    return new Promise((resolve, reject) => {
-      const output = plugins.fs.createWriteStream(destPath);
-
-      input.on('data', (chunk: Buffer) => {
-        hash.update(chunk);
-        totalSize += chunk.length;
-      });
-
-      input.on('error', reject);
-      output.on('error', reject);
-
-      input.pipe(output).on('finish', async () => {
-        const md5 = hash.digest('hex');
-
-        // Save MD5 to separate file
-        const md5Path = `${destPath}.md5`;
-        await plugins.fs.promises.writeFile(md5Path, md5);
-
-        resolve({ size: totalSize, md5 });
-      });
-    });
-  }
-
-  /**
-   * Read MD5 hash (calculate if missing)
-   */
-  private async readMD5(objectPath: string, md5Path: string): Promise<string> {
-    try {
-      // Try to read cached MD5
-      const md5 = await plugins.smartfile.fs.toStringSync(md5Path);
-      return md5.trim();
-    } catch (err) {
-      // Calculate MD5 if not cached
-      return new Promise((resolve, reject) => {
-        const hash = plugins.crypto.createHash('md5');
-        const stream = plugins.fs.createReadStream(objectPath);
-
-        stream.on('data', (chunk: Buffer) => hash.update(chunk));
-        stream.on('end', async () => {
-          const md5 = hash.digest('hex');
-          // Cache it
-          await plugins.fs.promises.writeFile(md5Path, md5);
-          resolve(md5);
-        });
-        stream.on('error', reject);
-      });
-    }
-  }
-
-  /**
-   * Read metadata from JSON file
-   */
-  private async readMetadata(metadataPath: string): Promise<Record<string, string>> {
-    try {
-      const content = await plugins.smartfile.fs.toStringSync(metadataPath);
-      return JSON.parse(content);
-    } catch (err) {
-      return {};
-    }
-  }
-}
--- a/ts/classes/middleware-stack.ts
+++ b/ts/classes/middleware-stack.ts
@@ -1,43 +0,0 @@
-import * as plugins from '../plugins.js';
-import type { S3Context } from './context.js';
-
-export type Middleware = (
-  req: plugins.http.IncomingMessage,
-  res: plugins.http.ServerResponse,
-  ctx: S3Context,
-  next: () => Promise<void>
-) => Promise<void>;
-
-/**
- * Middleware stack for composing request handlers
- */
-export class MiddlewareStack {
-  private middlewares: Middleware[] = [];
-
-  /**
-   * Add middleware to the stack
-   */
-  public use(middleware: Middleware): void {
-    this.middlewares.push(middleware);
-  }
-
-  /**
-   * Execute all middlewares in order
-   */
-  public async execute(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    ctx: S3Context
-  ): Promise<void> {
-    let index = 0;
-
-    const next = async (): Promise<void> => {
-      if (index < this.middlewares.length) {
-        const middleware = this.middlewares[index++];
-        await middleware(req, res, ctx, next);
-      }
-    };
-
-    await next();
-  }
-}
--- a/ts/classes/router.ts
+++ b/ts/classes/router.ts
@@ -1,129 +0,0 @@
-import * as plugins from '../plugins.js';
-import type { S3Context } from './context.js';
-
-export type RouteHandler = (
-  req: plugins.http.IncomingMessage,
-  res: plugins.http.ServerResponse,
-  ctx: S3Context,
-  params: Record<string, string>
-) => Promise<void>;
-
-export interface IRouteMatch {
-  handler: RouteHandler;
-  params: Record<string, string>;
-}
-
-interface IRoute {
-  method: string;
-  pattern: RegExp;
-  paramNames: string[];
-  handler: RouteHandler;
-}
-
-/**
- * Simple HTTP router with pattern matching for S3 routes
- */
-export class S3Router {
-  private routes: IRoute[] = [];
-
-  /**
-   * Add a route with pattern matching
-   * Supports patterns like:
-   * - "/" (exact match)
-   * - "/:bucket" (single param)
-   * - "/:bucket/:key*" (param with wildcard - captures everything after)
-   */
-  public add(method: string, pattern: string, handler: RouteHandler): void {
-    const { regex, paramNames } = this.convertPatternToRegex(pattern);
-
-    this.routes.push({
-      method: method.toUpperCase(),
-      pattern: regex,
-      paramNames,
-      handler,
-    });
-  }
-
-  /**
-   * Match a request to a route
-   */
-  public match(method: string, pathname: string): IRouteMatch | null {
-    // Normalize pathname: remove trailing slash unless it's root
-    const normalizedPath = pathname === '/' ? pathname : pathname.replace(/\/$/, '');
-
-    for (const route of this.routes) {
-      if (route.method !== method.toUpperCase()) {
-        continue;
-      }
-
-      const match = normalizedPath.match(route.pattern);
-      if (match) {
-        // Extract params from captured groups
-        const params: Record<string, string> = {};
-        for (let i = 0; i < route.paramNames.length; i++) {
-          params[route.paramNames[i]] = decodeURIComponent(match[i + 1] || '');
-        }
-
-        return {
-          handler: route.handler,
-          params,
-        };
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Convert path pattern to RegExp
-   * Examples:
-   * - "/" → /^\/$/
-   * - "/:bucket" → /^\/([^/]+)$/
-   * - "/:bucket/:key*" → /^\/([^/]+)\/(.+)$/
-   */
-  private convertPatternToRegex(pattern: string): { regex: RegExp; paramNames: string[] } {
-    const paramNames: string[] = [];
-    let regexStr = pattern;
-
-    // Process all params in a single pass to maintain order
-    regexStr = regexStr.replace(/:(\w+)(\*)?/g, (match, paramName, isWildcard) => {
-      paramNames.push(paramName);
-      // :param* captures rest of path, :param captures single segment
-      return isWildcard ? '(.+)' : '([^/]+)';
-    });
-
-    // Escape special regex characters
-    regexStr = regexStr.replace(/\//g, '\\/');
-
-    // Add anchors
-    regexStr = `^${regexStr}$`;
-
-    return {
-      regex: new RegExp(regexStr),
-      paramNames,
-    };
-  }
-
-  /**
-   * Convenience methods for common HTTP methods
-   */
-  public get(pattern: string, handler: RouteHandler): void {
-    this.add('GET', pattern, handler);
-  }
-
-  public put(pattern: string, handler: RouteHandler): void {
-    this.add('PUT', pattern, handler);
-  }
-
-  public post(pattern: string, handler: RouteHandler): void {
-    this.add('POST', pattern, handler);
-  }
-
-  public delete(pattern: string, handler: RouteHandler): void {
-    this.add('DELETE', pattern, handler);
-  }
-
-  public head(pattern: string, handler: RouteHandler): void {
-    this.add('HEAD', pattern, handler);
-  }
-}
--- a/ts/classes/s3-error.ts
+++ b/ts/classes/s3-error.ts
@@ -1,145 +0,0 @@
-import * as plugins from '../plugins.js';
-
-/**
- * S3 error codes mapped to HTTP status codes
- */
-const S3_ERROR_CODES: Record<string, number> = {
-  'AccessDenied': 403,
-  'BadDigest': 400,
-  'BadRequest': 400,
-  'BucketAlreadyExists': 409,
-  'BucketAlreadyOwnedByYou': 409,
-  'BucketNotEmpty': 409,
-  'CredentialsNotSupported': 400,
-  'EntityTooSmall': 400,
-  'EntityTooLarge': 400,
-  'ExpiredToken': 400,
-  'IncompleteBody': 400,
-  'IncorrectNumberOfFilesInPostRequest': 400,
-  'InlineDataTooLarge': 400,
-  'InternalError': 500,
-  'InvalidArgument': 400,
-  'InvalidBucketName': 400,
-  'InvalidDigest': 400,
-  'InvalidLocationConstraint': 400,
-  'InvalidPart': 400,
-  'InvalidPartOrder': 400,
-  'InvalidRange': 416,
-  'InvalidRequest': 400,
-  'InvalidSecurity': 403,
-  'InvalidSOAPRequest': 400,
-  'InvalidStorageClass': 400,
-  'InvalidTargetBucketForLogging': 400,
-  'InvalidToken': 400,
-  'InvalidURI': 400,
-  'KeyTooLongError': 400,
-  'MalformedACLError': 400,
-  'MalformedPOSTRequest': 400,
-  'MalformedXML': 400,
-  'MaxMessageLengthExceeded': 400,
-  'MaxPostPreDataLengthExceededError': 400,
-  'MetadataTooLarge': 400,
-  'MethodNotAllowed': 405,
-  'MissingContentLength': 411,
-  'MissingRequestBodyError': 400,
-  'MissingSecurityElement': 400,
-  'MissingSecurityHeader': 400,
-  'NoLoggingStatusForKey': 400,
-  'NoSuchBucket': 404,
-  'NoSuchKey': 404,
-  'NoSuchLifecycleConfiguration': 404,
-  'NoSuchUpload': 404,
-  'NoSuchVersion': 404,
-  'NotImplemented': 501,
-  'NotSignedUp': 403,
-  'OperationAborted': 409,
-  'PermanentRedirect': 301,
-  'PreconditionFailed': 412,
-  'Redirect': 307,
-  'RequestIsNotMultiPartContent': 400,
-  'RequestTimeout': 400,
-  'RequestTimeTooSkewed': 403,
-  'RequestTorrentOfBucketError': 400,
-  'SignatureDoesNotMatch': 403,
-  'ServiceUnavailable': 503,
-  'SlowDown': 503,
-  'TemporaryRedirect': 307,
-  'TokenRefreshRequired': 400,
-  'TooManyBuckets': 400,
-  'UnexpectedContent': 400,
-  'UnresolvableGrantByEmailAddress': 400,
-  'UserKeyMustBeSpecified': 400,
-};
-
-/**
- * S3-compatible error class that formats errors as XML responses
- */
-export class S3Error extends Error {
-  public status: number;
-  public code: string;
-  public detail: Record<string, any>;
-
-  constructor(
-    code: string,
-    message: string,
-    detail: Record<string, any> = {}
-  ) {
-    super(message);
-    this.name = 'S3Error';
-    this.code = code;
-    this.status = S3_ERROR_CODES[code] || 500;
-    this.detail = detail;
-
-    // Maintain proper stack trace
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, S3Error);
-    }
-  }
-
-  /**
-   * Convert error to S3-compatible XML format
-   */
-  public toXML(): string {
-    const smartXmlInstance = new plugins.SmartXml();
-    const errorObj: any = {
-      Error: {
-        Code: this.code,
-        Message: this.message,
-        ...this.detail,
-      },
-    };
-
-    const xml = smartXmlInstance.createXmlFromObject(errorObj);
-
-    // Ensure XML declaration
-    if (!xml.startsWith('<?xml')) {
-      return `<?xml version="1.0" encoding="UTF-8"?>\n${xml}`;
-    }
-
-    return xml;
-  }
-
-  /**
-   * Create S3Error from a generic Error
-   */
-  public static fromError(err: any): S3Error {
-    if (err instanceof S3Error) {
-      return err;
-    }
-
-    // Map common errors
-    if (err.code === 'ENOENT') {
-      return new S3Error('NoSuchKey', 'The specified key does not exist.');
-    }
-    if (err.code === 'EACCES') {
-      return new S3Error('AccessDenied', 'Access Denied');
-    }
-
-    // Default to internal error
-    return new S3Error(
-      'InternalError',
-      'We encountered an internal error. Please try again.',
-      { OriginalError: err.message }
-    );
-  }
-}
--- a/ts/classes/smarts3-server.ts
+++ b/ts/classes/smarts3-server.ts
@@ -1,239 +0,0 @@
-import * as plugins from '../plugins.js';
-import { S3Router } from './router.js';
-import { MiddlewareStack } from './middleware-stack.js';
-import { S3Context } from './context.js';
-import { FilesystemStore } from './filesystem-store.js';
-import { S3Error } from './s3-error.js';
-import { ServiceController } from '../controllers/service.controller.js';
-import { BucketController } from '../controllers/bucket.controller.js';
-import { ObjectController } from '../controllers/object.controller.js';
-
-export interface ISmarts3ServerOptions {
-  port?: number;
-  address?: string;
-  directory?: string;
-  cleanSlate?: boolean;
-  silent?: boolean;
-}
-
-/**
- * Custom S3-compatible server implementation
- * Built on native Node.js http module with zero framework dependencies
- */
-export class Smarts3Server {
-  private httpServer?: plugins.http.Server;
-  private router: S3Router;
-  private middlewares: MiddlewareStack;
-  private store: FilesystemStore;
-  private options: Required<ISmarts3ServerOptions>;
-
-  constructor(options: ISmarts3ServerOptions = {}) {
-    this.options = {
-      port: 3000,
-      address: '0.0.0.0',
-      directory: plugins.path.join(process.cwd(), '.nogit/bucketsDir'),
-      cleanSlate: false,
-      silent: false,
-      ...options,
-    };
-
-    this.store = new FilesystemStore(this.options.directory);
-    this.router = new S3Router();
-    this.middlewares = new MiddlewareStack();
-
-    this.setupMiddlewares();
-    this.setupRoutes();
-  }
-
-  /**
-   * Setup middleware stack
-   */
-  private setupMiddlewares(): void {
-    // Logger middleware
-    if (!this.options.silent) {
-      this.middlewares.use(async (req, res, ctx, next) => {
-        const start = Date.now();
-        console.log(`→ ${req.method} ${req.url}`);
-        console.log(`  Headers:`, JSON.stringify(req.headers, null, 2).slice(0, 200));
-        await next();
-        const duration = Date.now() - start;
-        console.log(`← ${req.method} ${req.url} - ${res.statusCode} (${duration}ms)`);
-      });
-    }
-
-    // TODO: Add authentication middleware
-    // TODO: Add CORS middleware
-  }
-
-  /**
-   * Setup routes
-   */
-  private setupRoutes(): void {
-    // Service level (/)
-    this.router.get('/', ServiceController.listBuckets);
-
-    // Bucket level (/:bucket)
-    this.router.put('/:bucket', BucketController.createBucket);
-    this.router.delete('/:bucket', BucketController.deleteBucket);
-    this.router.get('/:bucket', BucketController.listObjects);
-    this.router.head('/:bucket', BucketController.headBucket);
-
-    // Object level (/:bucket/:key*)
-    this.router.put('/:bucket/:key*', ObjectController.putObject);
-    this.router.get('/:bucket/:key*', ObjectController.getObject);
-    this.router.head('/:bucket/:key*', ObjectController.headObject);
-    this.router.delete('/:bucket/:key*', ObjectController.deleteObject);
-  }
-
-  /**
-   * Handle incoming HTTP request
-   */
-  private async handleRequest(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse
-  ): Promise<void> {
-    const context = new S3Context(req, res, this.store);
-
-    try {
-      // Execute middleware stack
-      await this.middlewares.execute(req, res, context);
-
-      // Route to handler
-      const match = this.router.match(context.method, context.url.pathname);
-
-      if (match) {
-        context.params = match.params;
-        await match.handler(req, res, context, match.params);
-      } else {
-        context.throw('NoSuchKey', 'The specified resource does not exist');
-      }
-    } catch (err) {
-      await this.handleError(err, context, res);
-    }
-  }
-
-  /**
-   * Handle errors and send S3-compatible error responses
-   */
-  private async handleError(
-    err: any,
-    context: S3Context,
-    res: plugins.http.ServerResponse
-  ): Promise<void> {
-    const s3Error = err instanceof S3Error ? err : S3Error.fromError(err);
-
-    if (!this.options.silent) {
-      console.error(`[S3Error] ${s3Error.code}: ${s3Error.message}`);
-      if (s3Error.status >= 500) {
-        console.error(err.stack || err);
-      }
-    }
-
-    // Send error response
-    const errorXml = s3Error.toXML();
-
-    res.writeHead(s3Error.status, {
-      'Content-Type': 'application/xml',
-      'Content-Length': Buffer.byteLength(errorXml),
-    });
-
-    res.end(errorXml);
-  }
-
-  /**
-   * Start the server
-   */
-  public async start(): Promise<void> {
-    // Initialize store
-    await this.store.initialize();
-
-    // Clean slate if requested
-    if (this.options.cleanSlate) {
-      await this.store.reset();
-    }
-
-    // Create HTTP server
-    this.httpServer = plugins.http.createServer((req, res) => {
-      this.handleRequest(req, res).catch((err) => {
-        console.error('Fatal error in request handler:', err);
-        if (!res.headersSent) {
-          res.writeHead(500, { 'Content-Type': 'text/plain' });
-          res.end('Internal Server Error');
-        }
-      });
-    });
-
-    // Start listening
-    await new Promise<void>((resolve, reject) => {
-      this.httpServer!.listen(this.options.port, this.options.address, (err?: Error) => {
-        if (err) {
-          reject(err);
-        } else {
-          if (!this.options.silent) {
-            console.log(`S3 server listening on ${this.options.address}:${this.options.port}`);
-          }
-          resolve();
-        }
-      });
-    });
-  }
-
-  /**
-   * Stop the server
-   */
-  public async stop(): Promise<void> {
-    if (!this.httpServer) {
-      return;
-    }
-
-    await new Promise<void>((resolve, reject) => {
-      this.httpServer!.close((err?: Error) => {
-        if (err) {
-          reject(err);
-        } else {
-          if (!this.options.silent) {
-            console.log('S3 server stopped');
-          }
-          resolve();
-        }
-      });
-    });
-
-    this.httpServer = undefined;
-  }
-
-  /**
-   * Get server port (useful for testing with random ports)
-   */
-  public getPort(): number {
-    if (!this.httpServer) {
-      throw new Error('Server not started');
-    }
-
-    const address = this.httpServer.address();
-    if (typeof address === 'string') {
-      throw new Error('Unix socket not supported');
-    }
-
-    return address?.port || this.options.port;
-  }
-
-  /**
-   * Get S3 descriptor for client configuration
-   */
-  public getS3Descriptor(): {
-    accessKey: string;
-    accessSecret: string;
-    endpoint: string;
-    port: number;
-    useSsl: boolean;
-  } {
-    return {
-      accessKey: 'S3RVER',
-      accessSecret: 'S3RVER',
-      endpoint: this.options.address === '0.0.0.0' ? '127.0.0.1' : this.options.address,
-      port: this.getPort(),
-      useSsl: false,
-    };
-  }
-}
--- a/ts/controllers/bucket.controller.ts
+++ b/ts/controllers/bucket.controller.ts
@@ -1,130 +0,0 @@
-import * as plugins from '../plugins.js';
-import type { S3Context } from '../classes/context.js';
-
-/**
- * Bucket-level operations
- */
-export class BucketController {
-  /**
-   * HEAD /:bucket - Check if bucket exists
-   */
-  public static async headBucket(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    ctx: S3Context,
-    params: Record<string, string>
-  ): Promise<void> {
-    const { bucket } = params;
-
-    if (await ctx.store.bucketExists(bucket)) {
-      ctx.status(200).send('');
-    } else {
-      ctx.throw('NoSuchBucket', 'The specified bucket does not exist');
-    }
-  }
-
-  /**
-   * PUT /:bucket - Create bucket
-   */
-  public static async createBucket(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    ctx: S3Context,
-    params: Record<string, string>
-  ): Promise<void> {
-    const { bucket } = params;
-
-    await ctx.store.createBucket(bucket);
-    ctx.status(200).send('');
-  }
-
-  /**
-   * DELETE /:bucket - Delete bucket
-   */
-  public static async deleteBucket(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    ctx: S3Context,
-    params: Record<string, string>
-  ): Promise<void> {
-    const { bucket } = params;
-
-    await ctx.store.deleteBucket(bucket);
-    ctx.status(204).send('');
-  }
-
-  /**
-   * GET /:bucket - List objects
-   * Supports both V1 and V2 listing (V2 uses list-type=2 query param)
-   */
-  public static async listObjects(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    ctx: S3Context,
-    params: Record<string, string>
-  ): Promise<void> {
-    const { bucket } = params;
-    const isV2 = ctx.query['list-type'] === '2';
-
-    const result = await ctx.store.listObjects(bucket, {
-      prefix: ctx.query.prefix,
-      delimiter: ctx.query.delimiter,
-      maxKeys: ctx.query['max-keys'] ? parseInt(ctx.query['max-keys']) : 1000,
-      continuationToken: ctx.query['continuation-token'],
-    });
-
-    if (isV2) {
-      // List Objects V2 response
-      await ctx.sendXML({
-        ListBucketResult: {
-          '@_xmlns': 'http://s3.amazonaws.com/doc/2006-03-01/',
-          Name: bucket,
-          Prefix: result.prefix || '',
-          MaxKeys: result.maxKeys,
-          KeyCount: result.contents.length,
-          IsTruncated: result.isTruncated,
-          ...(result.delimiter && { Delimiter: result.delimiter }),
-          ...(result.nextContinuationToken && {
-            NextContinuationToken: result.nextContinuationToken,
-          }),
-          ...(result.commonPrefixes.length > 0 && {
-            CommonPrefixes: result.commonPrefixes.map((prefix) => ({
-              Prefix: prefix,
-            })),
-          }),
-          Contents: result.contents.map((obj) => ({
-            Key: obj.key,
-            LastModified: obj.lastModified.toISOString(),
-            ETag: `"${obj.md5}"`,
-            Size: obj.size,
-            StorageClass: 'STANDARD',
-          })),
-        },
-      });
-    } else {
-      // List Objects V1 response
-      await ctx.sendXML({
-        ListBucketResult: {
-          '@_xmlns': 'http://s3.amazonaws.com/doc/2006-03-01/',
-          Name: bucket,
-          Prefix: result.prefix || '',
-          MaxKeys: result.maxKeys,
-          IsTruncated: result.isTruncated,
-          ...(result.delimiter && { Delimiter: result.delimiter }),
-          ...(result.commonPrefixes.length > 0 && {
-            CommonPrefixes: result.commonPrefixes.map((prefix) => ({
-              Prefix: prefix,
-            })),
-          }),
-          Contents: result.contents.map((obj) => ({
-            Key: obj.key,
-            LastModified: obj.lastModified.toISOString(),
-            ETag: `"${obj.md5}"`,
-            Size: obj.size,
-            StorageClass: 'STANDARD',
-          })),
-        },
-      });
-    }
-  }
-}
--- a/ts/controllers/object.controller.ts
+++ b/ts/controllers/object.controller.ts
@@ -1,204 +0,0 @@
-import * as plugins from '../plugins.js';
-import type { S3Context } from '../classes/context.js';
-
-/**
- * Object-level operations
- */
-export class ObjectController {
-  /**
-   * PUT /:bucket/:key* - Upload object or copy object
-   */
-  public static async putObject(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    ctx: S3Context,
-    params: Record<string, string>
-  ): Promise<void> {
-    const { bucket, key } = params;
-
-    // Check if this is a COPY operation
-    const copySource = ctx.headers['x-amz-copy-source'] as string | undefined;
-    if (copySource) {
-      return ObjectController.copyObject(req, res, ctx, params);
-    }
-
-    // Extract metadata from headers
-    const metadata: Record<string, string> = {};
-    for (const [header, value] of Object.entries(ctx.headers)) {
-      if (header.startsWith('x-amz-meta-')) {
-        metadata[header] = value as string;
-      }
-      if (header === 'content-type' && value) {
-        metadata['content-type'] = value as string;
-      }
-      if (header === 'cache-control' && value) {
-        metadata['cache-control'] = value as string;
-      }
-    }
-
-    // If no content-type, default to binary/octet-stream
-    if (!metadata['content-type']) {
-      metadata['content-type'] = 'binary/octet-stream';
-    }
-
-    // Stream upload
-    const result = await ctx.store.putObject(bucket, key, ctx.getRequestStream(), metadata);
-
-    ctx.setHeader('ETag', `"${result.md5}"`);
-    ctx.status(200).send('');
-  }
-
-  /**
-   * GET /:bucket/:key* - Download object
-   */
-  public static async getObject(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    ctx: S3Context,
-    params: Record<string, string>
-  ): Promise<void> {
-    const { bucket, key } = params;
-
-    // Parse Range header if present
-    const rangeHeader = ctx.headers.range as string | undefined;
-    let range: { start: number; end: number } | undefined;
-
-    if (rangeHeader) {
-      const matches = rangeHeader.match(/bytes=(\d+)-(\d*)/);
-      if (matches) {
-        const start = parseInt(matches[1]);
-        const end = matches[2] ? parseInt(matches[2]) : undefined;
-        range = { start, end: end || start + 1024 * 1024 }; // Default to 1MB if no end
-      }
-    }
-
-    // Get object
-    const object = await ctx.store.getObject(bucket, key, range);
-
-    // Set response headers
-    ctx.setHeader('ETag', `"${object.md5}"`);
-    ctx.setHeader('Last-Modified', object.lastModified.toUTCString());
-    ctx.setHeader('Content-Type', object.metadata['content-type'] || 'binary/octet-stream');
-    ctx.setHeader('Accept-Ranges', 'bytes');
-
-    // Handle custom metadata headers
-    for (const [key, value] of Object.entries(object.metadata)) {
-      if (key.startsWith('x-amz-meta-')) {
-        ctx.setHeader(key, value);
-      }
-    }
-
-    if (range) {
-      ctx.status(206);
-      ctx.setHeader('Content-Length', (range.end - range.start + 1).toString());
-      ctx.setHeader('Content-Range', `bytes ${range.start}-${range.end}/${object.size}`);
-    } else {
-      ctx.status(200);
-      ctx.setHeader('Content-Length', object.size.toString());
-    }
-
-    // Stream response
-    await ctx.send(object.content!);
-  }
-
-  /**
-   * HEAD /:bucket/:key* - Get object metadata
-   */
-  public static async headObject(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    ctx: S3Context,
-    params: Record<string, string>
-  ): Promise<void> {
-    const { bucket, key } = params;
-
-    // Get object (without content)
-    const object = await ctx.store.getObject(bucket, key);
-
-    // Set response headers (same as GET but no body)
-    ctx.setHeader('ETag', `"${object.md5}"`);
-    ctx.setHeader('Last-Modified', object.lastModified.toUTCString());
-    ctx.setHeader('Content-Type', object.metadata['content-type'] || 'binary/octet-stream');
-    ctx.setHeader('Content-Length', object.size.toString());
-    ctx.setHeader('Accept-Ranges', 'bytes');
-
-    // Handle custom metadata headers
-    for (const [key, value] of Object.entries(object.metadata)) {
-      if (key.startsWith('x-amz-meta-')) {
-        ctx.setHeader(key, value);
-      }
-    }
-
-    ctx.status(200).send('');
-  }
-
-  /**
-   * DELETE /:bucket/:key* - Delete object
-   */
-  public static async deleteObject(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    ctx: S3Context,
-    params: Record<string, string>
-  ): Promise<void> {
-    const { bucket, key } = params;
-
-    await ctx.store.deleteObject(bucket, key);
-    ctx.status(204).send('');
-  }
-
-  /**
-   * COPY operation (PUT with x-amz-copy-source header)
-   */
-  private static async copyObject(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    ctx: S3Context,
-    params: Record<string, string>
-  ): Promise<void> {
-    const { bucket: destBucket, key: destKey } = params;
-    const copySource = ctx.headers['x-amz-copy-source'] as string;
-
-    // Parse source bucket and key from copy source
-    // Format: /bucket/key or bucket/key
-    const sourcePath = copySource.startsWith('/') ? copySource.slice(1) : copySource;
-    const firstSlash = sourcePath.indexOf('/');
-    const srcBucket = decodeURIComponent(sourcePath.slice(0, firstSlash));
-    const srcKey = decodeURIComponent(sourcePath.slice(firstSlash + 1));
-
-    // Get metadata directive (COPY or REPLACE)
-    const metadataDirective = (ctx.headers['x-amz-metadata-directive'] as string)?.toUpperCase() || 'COPY';
-
-    // Extract new metadata if REPLACE
-    let newMetadata: Record<string, string> | undefined;
-    if (metadataDirective === 'REPLACE') {
-      newMetadata = {};
-      for (const [header, value] of Object.entries(ctx.headers)) {
-        if (header.startsWith('x-amz-meta-')) {
-          newMetadata[header] = value as string;
-        }
-        if (header === 'content-type' && value) {
-          newMetadata['content-type'] = value as string;
-        }
-      }
-    }
-
-    // Perform copy
-    const result = await ctx.store.copyObject(
-      srcBucket,
-      srcKey,
-      destBucket,
-      destKey,
-      metadataDirective as 'COPY' | 'REPLACE',
-      newMetadata
-    );
-
-    // Send XML response
-    await ctx.sendXML({
-      CopyObjectResult: {
-        LastModified: new Date().toISOString(),
-        ETag: `"${result.md5}"`,
-      },
-    });
-  }
-}
--- a/ts/controllers/service.controller.ts
+++ b/ts/controllers/service.controller.ts
@@ -1,35 +0,0 @@
-import * as plugins from '../plugins.js';
-import type { S3Context } from '../classes/context.js';
-
-/**
- * Service-level operations (root /)
- */
-export class ServiceController {
-  /**
-   * GET / - List all buckets
-   */
-  public static async listBuckets(
-    req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse,
-    ctx: S3Context,
-    params: Record<string, string>
-  ): Promise<void> {
-    const buckets = await ctx.store.listBuckets();
-
-    await ctx.sendXML({
-      ListAllMyBucketsResult: {
-        '@_xmlns': 'http://s3.amazonaws.com/doc/2006-03-01/',
-        Owner: {
-          ID: '123456789000',
-          DisplayName: 'S3rver',
-        },
-        Buckets: {
-          Bucket: buckets.map((bucket) => ({
-            Name: bucket.name,
-            CreationDate: bucket.creationDate.toISOString(),
-          })),
-        },
-      },
-    });
-  }
-}
--- a/ts/index.ts
+++ b/ts/index.ts
@@ -1,104 +1,249 @@
 import * as plugins from './plugins.js';
 import * as paths from './paths.js';
-import { Smarts3Server } from './classes/smarts3-server.js';

-export interface ISmarts3ContructorOptions {
-  port?: number;
-  cleanSlate?: boolean;
-  useCustomServer?: boolean; // Feature flag for custom server
+/**
+ * Authentication configuration
+ */
+export interface IAuthConfig {
+  enabled: boolean;
+  credentials: Array<{
+    accessKeyId: string;
+    secretAccessKey: string;
+  }>;
 }

+/**
+ * CORS configuration
+ */
+export interface ICorsConfig {
+  enabled: boolean;
+  allowedOrigins?: string[];
+  allowedMethods?: string[];
+  allowedHeaders?: string[];
+  exposedHeaders?: string[];
+  maxAge?: number;
+  allowCredentials?: boolean;
+}
+
+/**
+ * Logging configuration
+ */
+export interface ILoggingConfig {
+  level?: 'error' | 'warn' | 'info' | 'debug';
+  format?: 'text' | 'json';
+  enabled?: boolean;
+}
+
+/**
+ * Request limits configuration
+ */
+export interface ILimitsConfig {
+  maxObjectSize?: number;
+  maxMetadataSize?: number;
+  requestTimeout?: number;
+}
+
+/**
+ * Multipart upload configuration
+ */
+export interface IMultipartConfig {
+  expirationDays?: number;
+  cleanupIntervalMinutes?: number;
+}
+
+/**
+ * Server configuration
+ */
+export interface IServerConfig {
+  port?: number;
+  address?: string;
+  silent?: boolean;
+}
+
+/**
+ * Storage configuration
+ */
+export interface IStorageConfig {
+  directory?: string;
+  cleanSlate?: boolean;
+}
+
+/**
+ * Complete smarts3 configuration
+ */
+export interface ISmarts3Config {
+  server?: IServerConfig;
+  storage?: IStorageConfig;
+  auth?: IAuthConfig;
+  cors?: ICorsConfig;
+  logging?: ILoggingConfig;
+  limits?: ILimitsConfig;
+  multipart?: IMultipartConfig;
+}
+
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG: ISmarts3Config = {
+  server: {
+    port: 3000,
+    address: '0.0.0.0',
+    silent: false,
+  },
+  storage: {
+    directory: paths.bucketsDir,
+    cleanSlate: false,
+  },
+  auth: {
+    enabled: false,
+    credentials: [
+      {
+        accessKeyId: 'S3RVER',
+        secretAccessKey: 'S3RVER',
+      },
+    ],
+  },
+  cors: {
+    enabled: false,
+    allowedOrigins: ['*'],
+    allowedMethods: ['GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'OPTIONS'],
+    allowedHeaders: ['*'],
+    exposedHeaders: ['ETag', 'x-amz-request-id', 'x-amz-version-id'],
+    maxAge: 86400,
+    allowCredentials: false,
+  },
+  logging: {
+    level: 'info',
+    format: 'text',
+    enabled: true,
+  },
+  limits: {
+    maxObjectSize: 5 * 1024 * 1024 * 1024, // 5GB
+    maxMetadataSize: 2048,
+    requestTimeout: 300000, // 5 minutes
+  },
+  multipart: {
+    expirationDays: 7,
+    cleanupIntervalMinutes: 60,
+  },
+};
+
+/**
+ * Merge user config with defaults (deep merge)
+ */
+function mergeConfig(userConfig: ISmarts3Config): Required<ISmarts3Config> {
+  return {
+    server: {
+      ...DEFAULT_CONFIG.server!,
+      ...(userConfig.server || {}),
+    },
+    storage: {
+      ...DEFAULT_CONFIG.storage!,
+      ...(userConfig.storage || {}),
+    },
+    auth: {
+      ...DEFAULT_CONFIG.auth!,
+      ...(userConfig.auth || {}),
+    },
+    cors: {
+      ...DEFAULT_CONFIG.cors!,
+      ...(userConfig.cors || {}),
+    },
+    logging: {
+      ...DEFAULT_CONFIG.logging!,
+      ...(userConfig.logging || {}),
+    },
+    limits: {
+      ...DEFAULT_CONFIG.limits!,
+      ...(userConfig.limits || {}),
+    },
+    multipart: {
+      ...DEFAULT_CONFIG.multipart!,
+      ...(userConfig.multipart || {}),
+    },
+  };
+}
+
+/**
+ * IPC command type map for RustBridge
+ */
+type TRustS3Commands = {
+  start: { params: { config: Required<ISmarts3Config> }; result: {} };
+  stop: { params: {}; result: {} };
+  createBucket: { params: { name: string }; result: {} };
+};
+
+/**
+ * Main Smarts3 class - production-ready S3-compatible server
+ */
 export class Smarts3 {
  // STATIC
-  public static async createAndStart(
-    optionsArg: ConstructorParameters<typeof Smarts3>[0],
-  ) {
-    const smartS3Instance = new Smarts3(optionsArg);
+  public static async createAndStart(configArg: ISmarts3Config = {}) {
+    const smartS3Instance = new Smarts3(configArg);
    await smartS3Instance.start();
    return smartS3Instance;
  }

  // INSTANCE
-  public options: ISmarts3ContructorOptions;
-  public s3Instance: plugins.s3rver | Smarts3Server;
+  public config: Required<ISmarts3Config>;
+  private bridge: InstanceType<typeof plugins.RustBridge<TRustS3Commands>>;

-  constructor(optionsArg: ISmarts3ContructorOptions) {
-    this.options = {
-      useCustomServer: true, // Default to custom server
-      ...optionsArg,
-    };
+  constructor(configArg: ISmarts3Config = {}) {
+    this.config = mergeConfig(configArg);
+    this.bridge = new plugins.RustBridge<TRustS3Commands>({
+      binaryName: 'rusts3',
+      localPaths: [
+        plugins.path.join(paths.packageDir, 'dist_rust', 'rusts3'),
+        plugins.path.join(paths.packageDir, 'rust', 'target', 'release', 'rusts3'),
+        plugins.path.join(paths.packageDir, 'rust', 'target', 'debug', 'rusts3'),
+      ],
+      readyTimeoutMs: 30000,
+      requestTimeoutMs: 300000,
+    });
  }

  public async start() {
-    if (this.options.useCustomServer) {
-      // Use new custom server
-      this.s3Instance = new Smarts3Server({
-        port: this.options.port || 3000,
-        address: '0.0.0.0',
-        directory: paths.bucketsDir,
-        cleanSlate: this.options.cleanSlate || false,
-        silent: false,
-      });
-      await this.s3Instance.start();
-      console.log('s3 server is running (custom implementation)');
-    } else {
-      // Use legacy s3rver
-      if (this.options.cleanSlate) {
-        await plugins.smartfile.fs.ensureEmptyDir(paths.bucketsDir);
-      } else {
-        await plugins.smartfile.fs.ensureDir(paths.bucketsDir);
+    const spawned = await this.bridge.spawn();
+    if (!spawned) {
+      throw new Error('Failed to spawn rusts3 binary. Make sure it is compiled (pnpm build).');
    }
-      this.s3Instance = new plugins.s3rver({
-        port: this.options.port || 3000,
-        address: '0.0.0.0',
-        silent: false,
-        directory: paths.bucketsDir,
-      });
-      await (this.s3Instance as plugins.s3rver).run();
-      console.log('s3 server is running (legacy s3rver)');
+    await this.bridge.sendCommand('start', { config: this.config });
+
+    if (!this.config.server.silent) {
+      console.log('s3 server is running');
    }
  }

  public async getS3Descriptor(
    optionsArg?: Partial<plugins.tsclass.storage.IS3Descriptor>,
  ): Promise<plugins.tsclass.storage.IS3Descriptor> {
-    if (this.options.useCustomServer && this.s3Instance instanceof Smarts3Server) {
-      const descriptor = this.s3Instance.getS3Descriptor();
+    const cred = this.config.auth.credentials[0] || {
+      accessKeyId: 'S3RVER',
+      secretAccessKey: 'S3RVER',
+    };
+
+    const descriptor: plugins.tsclass.storage.IS3Descriptor = {
+      endpoint: this.config.server.address === '0.0.0.0' ? 'localhost' : this.config.server.address!,
+      port: this.config.server.port!,
+      useSsl: false,
+      accessKey: cred.accessKeyId,
+      accessSecret: cred.secretAccessKey,
+      bucketName: '',
+    };
+
    return {
      ...descriptor,
      ...(optionsArg ? optionsArg : {}),
    };
  }

-    // Legacy s3rver descriptor
-    return {
-      ...{
-        accessKey: 'S3RVER',
-        accessSecret: 'S3RVER',
-        endpoint: '127.0.0.1',
-        port: this.options.port || 3000,
-        useSsl: false,
-      },
-      ...(optionsArg ? optionsArg : {}),
-    };
-  }
-
  public async createBucket(bucketNameArg: string) {
-    const smartbucketInstance = new plugins.smartbucket.SmartBucket(
-      await this.getS3Descriptor(),
-    );
-    const bucket = await smartbucketInstance.createBucket(bucketNameArg);
-    return bucket;
+    await this.bridge.sendCommand('createBucket', { name: bucketNameArg });
+    return { name: bucketNameArg };
  }

  public async stop() {
-    if (this.s3Instance instanceof Smarts3Server) {
-      await this.s3Instance.stop();
-    } else {
-      await (this.s3Instance as plugins.s3rver).close();
+    await this.bridge.sendCommand('stop', {});
+    this.bridge.kill();
  }
 }
-}
-
-// Export the custom server class for direct use
-export { Smarts3Server } from './classes/smarts3-server.js';
--- a/ts/plugins.ts
+++ b/ts/plugins.ts
@@ -1,26 +1,15 @@
 // node native
 import * as path from 'path';
-import * as http from 'http';
-import * as crypto from 'crypto';
-import * as url from 'url';
-import * as fs from 'fs';

-export { path, http, crypto, url, fs };
+export { path };

 // @push.rocks scope
-import * as smartbucket from '@push.rocks/smartbucket';
-import * as smartfile from '@push.rocks/smartfile';
 import * as smartpath from '@push.rocks/smartpath';
-import { SmartXml } from '@push.rocks/smartxml';
+import { RustBridge } from '@push.rocks/smartrust';

-export { smartbucket, smartfile, smartpath, SmartXml };
+export { smartpath, RustBridge };

 // @tsclass scope
 import * as tsclass from '@tsclass/tsclass';

 export { tsclass };
-
-// thirdparty scope
-import s3rver from 's3rver';
-
-export { s3rver };
--- a/ts/utils/xml.utils.ts
+++ b/ts/utils/xml.utils.ts
@@ -1,39 +0,0 @@
-import * as plugins from '../plugins.js';
-
-// Create a singleton instance of SmartXml
-const smartXmlInstance = new plugins.SmartXml();
-
-/**
- * Parse XML string to JavaScript object
- */
-export function parseXml(xmlString: string): any {
-  return smartXmlInstance.parseXmlToObject(xmlString);
-}
-
-/**
- * Convert JavaScript object to XML string with XML declaration
- */
-export function createXml(obj: any, options: { format?: boolean } = {}): string {
-  const xml = smartXmlInstance.createXmlFromObject(obj);
-
-  // Ensure XML declaration is present
-  if (!xml.startsWith('<?xml')) {
-    return `<?xml version="1.0" encoding="UTF-8"?>\n${xml}`;
-  }
-
-  return xml;
-}
-
-/**
- * Helper to create S3-compatible XML responses with proper namespace
- */
-export function createS3Xml(rootElement: string, content: any, namespace = 'http://s3.amazonaws.com/doc/2006-03-01/'): string {
-  const obj: any = {
-    [rootElement]: {
-      '@_xmlns': namespace,
-      ...content,
-    },
-  };
-
-  return createXml(obj, { format: true });
-}
Author	SHA1	Message	Date
Juergen Kunz	0b9d8c4a72	v5.1.1 Some checks failed Default (tags) / security (push) Has been cancelled Details Default (tags) / test (push) Has been cancelled Details Default (tags) / release (push) Has been cancelled Details Default (tags) / metadata (push) Has been cancelled Details	2026-02-13 13:59:44 +00:00
Juergen Kunz	65eb266983	fix(smarts3): replace TypeScript server with Rust-powered core and IPC bridge	2026-02-13 13:59:44 +00:00
Juergen Kunz	54a0c2fb65	v5.1.0 Some checks failed Default (tags) / security (push) Successful in 38s Details Default (tags) / test (push) Failing after 37s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-23 23:31:26 +00:00
Juergen Kunz	648ff98c2d	feat(multipart): Implement full multipart upload support with persistent manager, periodic cleanup, and API integration	2025-11-23 23:31:26 +00:00
Juergen Kunz	d6f178bde6	v5.0.2 Some checks failed Default (tags) / security (push) Successful in 24s Details Default (tags) / test (push) Failing after 35s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-23 22:53:39 +00:00
Juergen Kunz	ffaef5cb15	fix(readme): Clarify contribution agreement requirement in README	2025-11-23 22:53:39 +00:00
Juergen Kunz	d4cc1d43ea	v5.0.1 Some checks failed Default (tags) / security (push) Successful in 35s Details Default (tags) / test (push) Failing after 35s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-23 22:52:19 +00:00
Juergen Kunz	759becdd04	fix(docs): Clarify README wording about S3 compatibility and AWS SDK usage	2025-11-23 22:52:19 +00:00
Juergen Kunz	51e8836227	v5.0.0 Some checks failed Default (tags) / security (push) Successful in 25s Details Default (tags) / test (push) Failing after 35s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-23 22:46:42 +00:00
Juergen Kunz	3c0a54e08b	BREAKING CHANGE(core): Production-ready S3-compatible server: nested config, multipart uploads, CORS, structured logging, SmartFS migration and improved error handling	2025-11-23 22:46:42 +00:00
Juergen Kunz	c074a5d2ed	v4.0.0 Some checks failed Default (tags) / security (push) Successful in 36s Details Default (tags) / test (push) Failing after 37s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-23 22:42:47 +00:00
Juergen Kunz	a9ba9de6be	BREAKING CHANGE(Smarts3): Migrate Smarts3 configuration to nested server/storage objects and remove legacy flat config support	2025-11-23 22:42:47 +00:00
Juergen Kunz	263e7a58b9	v3.2.0 Some checks failed Default (tags) / security (push) Successful in 25s Details Default (tags) / test (push) Failing after 35s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-23 22:41:46 +00:00
Juergen Kunz	74b81d7ba8	feat(multipart): Add multipart upload support with MultipartUploadManager and controller integration	2025-11-23 22:41:46 +00:00
Juergen Kunz	0d4837184f	v3.1.0 Some checks failed Default (tags) / security (push) Successful in 38s Details Default (tags) / test (push) Failing after 36s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-23 22:37:32 +00:00
Juergen Kunz	7f3de92961	feat(logging): Add structured Logger and integrate into Smarts3Server; pass full config to server	2025-11-23 22:37:32 +00:00
Juergen Kunz	a7bc902dd0	v3.0.4 Some checks failed Default (tags) / security (push) Successful in 34s Details Default (tags) / test (push) Failing after 36s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-23 22:31:44 +00:00
Juergen Kunz	95d78d0d08	fix(smarts3): Use filesystem store for bucket creation and remove smartbucket runtime dependency	2025-11-23 22:31:44 +00:00
Juergen Kunz	b62cb0bc97	v3.0.3 Some checks failed Default (tags) / security (push) Successful in 39s Details Default (tags) / test (push) Failing after 37s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-23 22:12:29 +00:00
Juergen Kunz	32346636e0	fix(filesystem): Migrate filesystem implementation to @push.rocks/smartfs and add Web Streams handling	2025-11-23 22:12:29 +00:00
Juergen Kunz	415ba3e76d	v3.0.2 Some checks failed Default (tags) / security (push) Successful in 41s Details Default (tags) / test (push) Failing after 36s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-21 18:36:27 +00:00
Juergen Kunz	6594f67d3e	fix(smarts3): Prepare patch release 3.0.2 — no code changes detected	2025-11-21 18:36:27 +00:00
Juergen Kunz	61974e0b54	v3.0.1 Some checks failed Default (tags) / security (push) Successful in 40s Details Default (tags) / test (push) Failing after 46s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-21 17:09:16 +00:00
Juergen Kunz	fc845956fa	fix(readme): Add Issue Reporting and Security section to README	2025-11-21 17:09:16 +00:00
Juergen Kunz	eec1e09d2b	v3.0.0 Some checks failed Default (tags) / security (push) Successful in 25s Details Default (tags) / test (push) Failing after 35s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-21 14:36:30 +00:00
Juergen Kunz	c3daf9d3f7	BREAKING CHANGE(Smarts3): Remove legacy s3rver backend, simplify Smarts3 server API, and bump dependencies	2025-11-21 14:36:30 +00:00