@btravstack/storage 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benoit TRAVERS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# @btravstack/storage
+
+> The object-storage port for [`@btravstack/core`](../core): one `Storage` an
+> application depends on, an in-memory adapter, an S3-compatible one with
+> presigned reads, and a span, a count and a log line per operation.
+
+📖 **[Documentation](https://btravstack.github.io/btravstack/reference/storage)** ·
+[API Reference](https://btravstack.github.io/btravstack/api/storage/)
+
+```sh
+pnpm add @btravstack/storage @btravstack/core @btravstack/config @btravstack/di unthrown
+```
+
+Four peer dependencies, plus `@aws-sdk/client-s3` and
+`@aws-sdk/s3-request-presigner` — optional, and needed only if you compose the
+S3 adapter. Instrumentation needs no peer of its own: the `Logger`, `Tracer`
+and `Meter` it depends on are
+[the kernel's ports](https://btravstack.github.io/btravstack/reference/core/observability).
+Node `>=20`.
+
+## A worked example
+
+<!-- doctest: group=order-temporal-worker -->
+<!-- doctest: prelude
+import { Module } from "@btravstack/di";
+import { Logger } from "@btravstack/core";
+import { observability } from "@btravstack/observability";
+import { otel } from "@btravstack/observability/otel";
+import { P } from "unthrown";
+-->
+
+Storing a document, and reading it back through a URL that carries no
+credentials:
+
+```ts
+import {
+  Port as InvoicePort,
+  Provider as InvoiceProvider,
+} from "@btravstack/di";
+import { Storage } from "@btravstack/storage";
+import type { AsyncResult } from "unthrown";
+
+class Invoices extends InvoicePort("ReadmeInvoices")<{
+  readonly store: (
+    tenantId: string,
+    id: string,
+    pdf: Uint8Array,
+  ) => AsyncResult<void, never>;
+  readonly link: (
+    tenantId: string,
+    id: string,
+  ) => AsyncResult<string | undefined, never>;
+}> {}
+
+// The tenant is in the key because the port has no slot for one — the same
+// rule a cache key follows.
+const keyFor = (tenantId: string, id: string) =>
+  `invoices/${tenantId}/${id}.pdf`;
+
+export const invoices = InvoiceProvider(Invoices)(
+  { storage: Storage },
+  {
+    sync: ({ storage }) => ({
+      store: (tenantId, id, pdf) =>
+        storage
+          .put(keyFor(tenantId, id), pdf, { contentType: "application/pdf" })
+          // A document that failed to store is YOUR decision to make; here it
+          // is swallowed because the instrumented store already logged and
+          // counted it one layer down.
+          .recoverErrCases((matcher) =>
+            matcher.with(P.tag("StorageUnavailable"), () => undefined),
+          ),
+      // Serving bytes through your own process is the anti-pattern this arm
+      // exists to avoid: the caller fetches the object directly, for a minute.
+      link: (tenantId, id) =>
+        storage
+          .presignedUrl(keyFor(tenantId, id), { ttlMs: 60_000 })
+          .recoverErrCases((matcher) =>
+            matcher
+              .with(P.tag("StorageUnavailable"), () => undefined)
+              .with(P.tag("PresignNotSupported"), () => undefined),
+          ),
+    }),
+  },
+);
+```
+
+The composition — the adapter, and whether operations are instrumented,
+decided here and nowhere else:
+
+```ts
+import { storage } from "@btravstack/storage";
+import { s3Storage } from "@btravstack/storage/s3";
+
+export const InvoicesApp = Module("InvoicesApp")({
+  imports: [
+    // Instrumented by default, which is why `observability()` and `otel()`
+    // are below. Pass `instrumented: false` for the same graph without them.
+    storage({ adapter: s3Storage() }),
+    observability(),
+    otel(),
+  ],
+  provides: [invoices],
+  exports: [Invoices, Logger],
+});
+```
+
+## Options
+
+| Option                                                      | Where                              | What it is                                                             |
+| ----------------------------------------------------------- | ---------------------------------- | ---------------------------------------------------------------------- |
+| `adapter`                                                   | `storage({ adapter })`             | the adapter module providing `StorageBackend` — required               |
+| `instrumented`                                              | `storage({ instrumented })`        | span, count and log every operation (default `true`; `false` opts out) |
+| `STORAGE_S3_ENDPOINT`                                       | environment, read by `s3Storage()` | the store's endpoint — required                                        |
+| `STORAGE_S3_BUCKET`                                         | environment                        | the bucket — required                                                  |
+| `STORAGE_S3_ACCESS_KEY_ID` / `STORAGE_S3_SECRET_ACCESS_KEY` | environment                        | the credentials — required                                             |
+| `STORAGE_S3_REGION`                                         | environment                        | default `us-east-1`                                                    |
+
+The full table — defaults, semantics and the reasoning — lives on
+[the reference page](https://btravstack.github.io/btravstack/reference/storage),
+which is this list's one detailed home.
+
+## What it decides, and what it does not
+
+**It decides** that a missing object is an ordinary answer rather than a fault
+(counted `not_found`, logged at `info`), that `delete` is idempotent, that
+presigning asks the store nothing — and that an adapter which cannot presign
+says so instead of minting a URL that would fail only in production.
+
+**It does not decide** what your keys look like, whether a failed write should
+fail your request, or how long a link should live. There is no streaming, no
+presigned writes, no listing and no bucket management; the reasons are in
+[`CLAUDE.md`](./CLAUDE.md).

package/dist/index.cjs

@@ -0,0 +1,144 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_storage = require("./storage-QVPXOcO6.cjs");
+let _btravstack_di = require("@btravstack/di");
+let unthrown = require("unthrown");
+let _btravstack_core = require("@btravstack/core");
+//#region src/memory.ts
+/**
+* The in-process adapter: a `Map`, and an honest refusal to presign.
+*
+* `presignedUrl` answers `PresignNotSupported` rather than minting a fake URL,
+* which would be the worst kind of double — one that passes locally and fails in
+* the deployment for a reason no test could have shown.
+*
+* ponytail: no size limit, so a process storing unbounded objects grows
+* unbounded. The upgrade path is the S3 adapter.
+*/
+const memoryStorageBackend = () => {
+	const objects = /* @__PURE__ */ new Map();
+	return {
+		put: (key, bytes, options) => {
+			objects.set(key, {
+				bytes,
+				contentType: options.contentType
+			});
+			return (0, unthrown.OkAsync)();
+		},
+		get: (key) => {
+			const object = objects.get(key);
+			return object === void 0 ? (0, unthrown.ErrAsync)(new require_storage.ObjectNotFound({ key })) : (0, unthrown.OkAsync)(object);
+		},
+		delete: (key) => {
+			objects.delete(key);
+			return (0, unthrown.OkAsync)();
+		},
+		presignedUrl: (key) => (0, unthrown.ErrAsync)(new require_storage.PresignNotSupported({ key }))
+	};
+};
+/** The adapter as a provider, which is the shape `@btravstack/testing`'s `overridden` takes. */
+const memoryStorageProvider = () => (0, _btravstack_di.Provider)(require_storage.StorageBackend)({}, { sync: () => memoryStorageBackend() });
+/** The adapter as a module, which is the shape `storage({ adapter })` takes. */
+const memoryStorage = () => (0, _btravstack_di.Module)("MemoryStorage")({
+	provides: [memoryStorageProvider()],
+	exports: [require_storage.StorageBackend]
+});
+//#endregion
+//#region src/instrument.ts
+/**
+* One operation, wrapped: a span around it, a count of how it came out, and a
+* log line if it failed.
+*
+* **A missing object is counted `not_found` and logged at `info`, not
+* `error`.** Asking for something that is not there is an ordinary answer, and
+* a dashboard that treats it as a fault teaches its readers to ignore the fault
+* line. `StorageUnavailable` is what pages somebody.
+*/
+const observed = (call, { operation, key, logger, tracer, operations }) => {
+	const span = tracer.startSpan(`storage.${operation}`);
+	span.setAttributes({ "btravstack.storage.key": key });
+	return call().tap(() => {
+		operations.add(1, {
+			operation,
+			outcome: "ok"
+		});
+		span.end();
+	}).tapFailure((failure) => {
+		const cause = failure.tag === "Err" ? failure.error : failure.cause;
+		const message = failure.tag !== "Err" ? void 0 : failure.error._tag === "ObjectNotFound" ? "the object was not there" : failure.error._tag === "PresignNotSupported" ? "this store cannot mint a url" : void 0;
+		operations.add(1, {
+			operation,
+			outcome: message === void 0 ? "error" : "not_found"
+		});
+		if (message === void 0) {
+			logger.error("the store could not answer", {
+				operation,
+				key
+			}, cause);
+			span.setStatus({ code: _btravstack_core.SPAN_STATUS.error });
+		} else logger.info(message, {
+			operation,
+			key
+		});
+		span.end();
+	});
+};
+const instrument = (backend, logger, tracer, meter) => {
+	const operations = meter.createCounter("btravstack.storage.operations", { description: "Storage operations, by operation and outcome" });
+	const context = (operation, key) => ({
+		operation,
+		key,
+		logger,
+		tracer,
+		operations
+	});
+	return {
+		put: (key, bytes, options) => observed(() => backend.put(key, bytes, options), context("put", key)),
+		get: (key) => observed(() => backend.get(key), context("get", key)),
+		delete: (key) => observed(() => backend.delete(key), context("delete", key)),
+		presignedUrl: (key, options) => observed(() => backend.presignedUrl(key, options), context("presigned_url", key))
+	};
+};
+//#endregion
+//#region src/module.ts
+/**
+* The storage starter: an adapter, and `Storage` provided from it —
+* instrumented or not, decided here at the composition root.
+*
+* ```ts
+* storage({ adapter: s3Storage() });                      // spans, counts, log lines
+* storage({ adapter: s3Storage(), instrumented: false }); // just a store
+* ```
+*
+* **Two ports, because di allows one provider per port per graph**: the port an
+* application depends on must not be the one an adapter provides, which is also
+* why instrumentation is a flag on the composition rather than a wrapper.
+*/
+const storage = ({ adapter, instrumented }) => instrumented !== false ? (0, _btravstack_di.Module)("InstrumentedStorage")({
+	needs: [
+		_btravstack_core.Logger,
+		_btravstack_core.Meter,
+		_btravstack_core.Tracer
+	],
+	imports: [adapter],
+	provides: [(0, _btravstack_di.Provider)(require_storage.Storage)({
+		backend: require_storage.StorageBackend,
+		logger: _btravstack_core.Logger,
+		tracer: _btravstack_core.Tracer,
+		meter: _btravstack_core.Meter
+	}, { sync: ({ backend, logger, tracer, meter }) => instrument(backend, logger, tracer, meter) })],
+	exports: [require_storage.Storage]
+}) : (0, _btravstack_di.Module)("Storage")({
+	imports: [adapter],
+	provides: [(0, _btravstack_di.Provider)(require_storage.Storage)({ backend: require_storage.StorageBackend }, { sync: ({ backend }) => backend })],
+	exports: [require_storage.Storage]
+});
+//#endregion
+exports.ObjectNotFound = require_storage.ObjectNotFound;
+exports.PresignNotSupported = require_storage.PresignNotSupported;
+exports.Storage = require_storage.Storage;
+exports.StorageBackend = require_storage.StorageBackend;
+exports.StorageUnavailable = require_storage.StorageUnavailable;
+exports.memoryStorage = memoryStorage;
+exports.memoryStorageBackend = memoryStorageBackend;
+exports.memoryStorageProvider = memoryStorageProvider;
+exports.storage = storage;

package/dist/index.d.cts

@@ -0,0 +1,56 @@
+import { a as StorageService, i as StorageBackend, n as PresignNotSupported, o as StorageUnavailable, r as Storage, s as StoredObject, t as ObjectNotFound } from "./storage-C9j3zj7r.cjs";
+import { Module, Provider } from "@btravstack/di";
+import { Logger, Meter, Tracer } from "@btravstack/core";
+//#region src/memory.d.ts
+/**
+ * The in-process adapter: a `Map`, and an honest refusal to presign.
+ *
+ * `presignedUrl` answers `PresignNotSupported` rather than minting a fake URL,
+ * which would be the worst kind of double — one that passes locally and fails in
+ * the deployment for a reason no test could have shown.
+ *
+ * ponytail: no size limit, so a process storing unbounded objects grows
+ * unbounded. The upgrade path is the S3 adapter.
+ */
+declare const memoryStorageBackend: () => StorageService;
+/** The adapter as a provider, which is the shape `@btravstack/testing`'s `overridden` takes. */
+declare const memoryStorageProvider: () => Provider<StorageBackend, never, never> & {
+  readonly port: typeof StorageBackend;
+};
+/** The adapter as a module, which is the shape `storage({ adapter })` takes. */
+declare const memoryStorage: () => Module<StorageBackend, never, never>;
+//#endregion
+//#region src/module.d.ts
+type StorageOptions<E, N, Instrumented extends boolean> = {
+  /**
+   * The adapter module: `memoryStorage()` from this entry point,
+   * `s3Storage()` from `@btravstack/storage/s3`, or one an application
+   * wrote itself over `StorageBackend`.
+   */
+  readonly adapter: Module<StorageBackend, E, N>;
+  /**
+   * Span, count and log every operation. **Default `true`**, `false` opts out.
+   *
+   * On by default because telemetry that is missing is discovered during an
+   * incident. The cost is stated rather than hidden: instrumenting puts
+   * `Logger`, `Meter` and `Tracer` in this module's `Needs`, so a root without
+   * `observability()` and `otel()` gets a compile error naming all three.
+   */
+  readonly instrumented?: Instrumented;
+};
+/**
+ * The storage starter: an adapter, and `Storage` provided from it —
+ * instrumented or not, decided here at the composition root.
+ *
+ * ```ts
+ * storage({ adapter: s3Storage() });                      // spans, counts, log lines
+ * storage({ adapter: s3Storage(), instrumented: false }); // just a store
+ * ```
+ *
+ * **Two ports, because di allows one provider per port per graph**: the port an
+ * application depends on must not be the one an adapter provides, which is also
+ * why instrumentation is a flag on the composition rather than a wrapper.
+ */
+declare const storage: <E, N, Instrumented extends boolean = true>({ adapter, instrumented }: StorageOptions<E, N, Instrumented>) => Module<Storage, E, Instrumented extends true ? N | Logger | Meter | Tracer : N>;
+//#endregion
+export { ObjectNotFound, PresignNotSupported, Storage, StorageBackend, type StorageOptions, type StorageService, StorageUnavailable, type StoredObject, memoryStorage, memoryStorageBackend, memoryStorageProvider, storage };

package/dist/index.d.mts

@@ -0,0 +1,56 @@
+import { a as StorageService, i as StorageBackend, n as PresignNotSupported, o as StorageUnavailable, r as Storage, s as StoredObject, t as ObjectNotFound } from "./storage-C9j3zj7r.mjs";
+import { Module, Provider } from "@btravstack/di";
+import { Logger, Meter, Tracer } from "@btravstack/core";
+//#region src/memory.d.ts
+/**
+ * The in-process adapter: a `Map`, and an honest refusal to presign.
+ *
+ * `presignedUrl` answers `PresignNotSupported` rather than minting a fake URL,
+ * which would be the worst kind of double — one that passes locally and fails in
+ * the deployment for a reason no test could have shown.
+ *
+ * ponytail: no size limit, so a process storing unbounded objects grows
+ * unbounded. The upgrade path is the S3 adapter.
+ */
+declare const memoryStorageBackend: () => StorageService;
+/** The adapter as a provider, which is the shape `@btravstack/testing`'s `overridden` takes. */
+declare const memoryStorageProvider: () => Provider<StorageBackend, never, never> & {
+  readonly port: typeof StorageBackend;
+};
+/** The adapter as a module, which is the shape `storage({ adapter })` takes. */
+declare const memoryStorage: () => Module<StorageBackend, never, never>;
+//#endregion
+//#region src/module.d.ts
+type StorageOptions<E, N, Instrumented extends boolean> = {
+  /**
+   * The adapter module: `memoryStorage()` from this entry point,
+   * `s3Storage()` from `@btravstack/storage/s3`, or one an application
+   * wrote itself over `StorageBackend`.
+   */
+  readonly adapter: Module<StorageBackend, E, N>;
+  /**
+   * Span, count and log every operation. **Default `true`**, `false` opts out.
+   *
+   * On by default because telemetry that is missing is discovered during an
+   * incident. The cost is stated rather than hidden: instrumenting puts
+   * `Logger`, `Meter` and `Tracer` in this module's `Needs`, so a root without
+   * `observability()` and `otel()` gets a compile error naming all three.
+   */
+  readonly instrumented?: Instrumented;
+};
+/**
+ * The storage starter: an adapter, and `Storage` provided from it —
+ * instrumented or not, decided here at the composition root.
+ *
+ * ```ts
+ * storage({ adapter: s3Storage() });                      // spans, counts, log lines
+ * storage({ adapter: s3Storage(), instrumented: false }); // just a store
+ * ```
+ *
+ * **Two ports, because di allows one provider per port per graph**: the port an
+ * application depends on must not be the one an adapter provides, which is also
+ * why instrumentation is a flag on the composition rather than a wrapper.
+ */
+declare const storage: <E, N, Instrumented extends boolean = true>({ adapter, instrumented }: StorageOptions<E, N, Instrumented>) => Module<Storage, E, Instrumented extends true ? N | Logger | Meter | Tracer : N>;
+//#endregion
+export { ObjectNotFound, PresignNotSupported, Storage, StorageBackend, type StorageOptions, type StorageService, StorageUnavailable, type StoredObject, memoryStorage, memoryStorageBackend, memoryStorageProvider, storage };

package/dist/index.mjs

@@ -0,0 +1,135 @@
+import { a as StorageUnavailable, i as StorageBackend, n as PresignNotSupported, r as Storage, t as ObjectNotFound } from "./storage-CRkwIhac.mjs";
+import { Module, Provider } from "@btravstack/di";
+import { ErrAsync, OkAsync } from "unthrown";
+import { Logger, Meter, SPAN_STATUS, Tracer } from "@btravstack/core";
+//#region src/memory.ts
+/**
+* The in-process adapter: a `Map`, and an honest refusal to presign.
+*
+* `presignedUrl` answers `PresignNotSupported` rather than minting a fake URL,
+* which would be the worst kind of double — one that passes locally and fails in
+* the deployment for a reason no test could have shown.
+*
+* ponytail: no size limit, so a process storing unbounded objects grows
+* unbounded. The upgrade path is the S3 adapter.
+*/
+const memoryStorageBackend = () => {
+	const objects = /* @__PURE__ */ new Map();
+	return {
+		put: (key, bytes, options) => {
+			objects.set(key, {
+				bytes,
+				contentType: options.contentType
+			});
+			return OkAsync();
+		},
+		get: (key) => {
+			const object = objects.get(key);
+			return object === void 0 ? ErrAsync(new ObjectNotFound({ key })) : OkAsync(object);
+		},
+		delete: (key) => {
+			objects.delete(key);
+			return OkAsync();
+		},
+		presignedUrl: (key) => ErrAsync(new PresignNotSupported({ key }))
+	};
+};
+/** The adapter as a provider, which is the shape `@btravstack/testing`'s `overridden` takes. */
+const memoryStorageProvider = () => Provider(StorageBackend)({}, { sync: () => memoryStorageBackend() });
+/** The adapter as a module, which is the shape `storage({ adapter })` takes. */
+const memoryStorage = () => Module("MemoryStorage")({
+	provides: [memoryStorageProvider()],
+	exports: [StorageBackend]
+});
+//#endregion
+//#region src/instrument.ts
+/**
+* One operation, wrapped: a span around it, a count of how it came out, and a
+* log line if it failed.
+*
+* **A missing object is counted `not_found` and logged at `info`, not
+* `error`.** Asking for something that is not there is an ordinary answer, and
+* a dashboard that treats it as a fault teaches its readers to ignore the fault
+* line. `StorageUnavailable` is what pages somebody.
+*/
+const observed = (call, { operation, key, logger, tracer, operations }) => {
+	const span = tracer.startSpan(`storage.${operation}`);
+	span.setAttributes({ "btravstack.storage.key": key });
+	return call().tap(() => {
+		operations.add(1, {
+			operation,
+			outcome: "ok"
+		});
+		span.end();
+	}).tapFailure((failure) => {
+		const cause = failure.tag === "Err" ? failure.error : failure.cause;
+		const message = failure.tag !== "Err" ? void 0 : failure.error._tag === "ObjectNotFound" ? "the object was not there" : failure.error._tag === "PresignNotSupported" ? "this store cannot mint a url" : void 0;
+		operations.add(1, {
+			operation,
+			outcome: message === void 0 ? "error" : "not_found"
+		});
+		if (message === void 0) {
+			logger.error("the store could not answer", {
+				operation,
+				key
+			}, cause);
+			span.setStatus({ code: SPAN_STATUS.error });
+		} else logger.info(message, {
+			operation,
+			key
+		});
+		span.end();
+	});
+};
+const instrument = (backend, logger, tracer, meter) => {
+	const operations = meter.createCounter("btravstack.storage.operations", { description: "Storage operations, by operation and outcome" });
+	const context = (operation, key) => ({
+		operation,
+		key,
+		logger,
+		tracer,
+		operations
+	});
+	return {
+		put: (key, bytes, options) => observed(() => backend.put(key, bytes, options), context("put", key)),
+		get: (key) => observed(() => backend.get(key), context("get", key)),
+		delete: (key) => observed(() => backend.delete(key), context("delete", key)),
+		presignedUrl: (key, options) => observed(() => backend.presignedUrl(key, options), context("presigned_url", key))
+	};
+};
+//#endregion
+//#region src/module.ts
+/**
+* The storage starter: an adapter, and `Storage` provided from it —
+* instrumented or not, decided here at the composition root.
+*
+* ```ts
+* storage({ adapter: s3Storage() });                      // spans, counts, log lines
+* storage({ adapter: s3Storage(), instrumented: false }); // just a store
+* ```
+*
+* **Two ports, because di allows one provider per port per graph**: the port an
+* application depends on must not be the one an adapter provides, which is also
+* why instrumentation is a flag on the composition rather than a wrapper.
+*/
+const storage = ({ adapter, instrumented }) => instrumented !== false ? Module("InstrumentedStorage")({
+	needs: [
+		Logger,
+		Meter,
+		Tracer
+	],
+	imports: [adapter],
+	provides: [Provider(Storage)({
+		backend: StorageBackend,
+		logger: Logger,
+		tracer: Tracer,
+		meter: Meter
+	}, { sync: ({ backend, logger, tracer, meter }) => instrument(backend, logger, tracer, meter) })],
+	exports: [Storage]
+}) : Module("Storage")({
+	imports: [adapter],
+	provides: [Provider(Storage)({ backend: StorageBackend }, { sync: ({ backend }) => backend })],
+	exports: [Storage]
+});
+//#endregion
+export { ObjectNotFound, PresignNotSupported, Storage, StorageBackend, StorageUnavailable, memoryStorage, memoryStorageBackend, memoryStorageProvider, storage };

package/dist/s3.cjs

@@ -0,0 +1,103 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_storage = require("./storage-QVPXOcO6.cjs");
+let _btravstack_di = require("@btravstack/di");
+let unthrown = require("unthrown");
+let _aws_sdk_client_s3 = require("@aws-sdk/client-s3");
+let _aws_sdk_s3_request_presigner = require("@aws-sdk/s3-request-presigner");
+let _btravstack_config = require("@btravstack/config");
+//#region src/s3.ts
+/** What the graph bound from the environment for the S3 adapter. */
+var StorageConfig = class extends (0, _btravstack_di.Port)("StorageConfig") {};
+/**
+* The five variables an S3-compatible store needs, and no sixth.
+*
+* `STORAGE_S3_ENDPOINT` is required rather than defaulted to AWS: every store
+* this port exists for has one, and a default pointing at Amazon would be a
+* surprising bill. **Path-style addressing is not configurable**, it is simply
+* on — every self-hosted store requires it and AWS accepts it, so it is a value
+* that never changes.
+*/
+const s3Schema = _btravstack_config.Config.object({
+	endpoint: _btravstack_config.Config.string("STORAGE_S3_ENDPOINT"),
+	region: _btravstack_config.Config.string("STORAGE_S3_REGION", { default: "us-east-1" }),
+	bucket: _btravstack_config.Config.string("STORAGE_S3_BUCKET"),
+	accessKeyId: _btravstack_config.Config.string("STORAGE_S3_ACCESS_KEY_ID"),
+	secretAccessKey: _btravstack_config.Config.string("STORAGE_S3_SECRET_ACCESS_KEY")
+});
+/**
+* The client, as a port of its own: a resourceful provider is handed back the
+* service it acquired, and a store's four methods are not something you can
+* close — so the client rides the graph and the scope closing destroys it.
+*/
+var S3Connection = class extends (0, _btravstack_di.Port)("S3Connection") {};
+const unavailable = (operation, key, cause) => new require_storage.StorageUnavailable({
+	operation,
+	key,
+	reason: cause instanceof Error ? cause.message : String(cause)
+});
+/** A missing key is S3's `NoSuchKey`, which is a different fact from "the store is down". */
+const isMissing = (cause) => cause instanceof Error && (cause.name === "NoSuchKey" || cause.name === "NotFound");
+/**
+* The adapter's service over a client and a bucket. A delete of a key nobody
+* stored answers `Ok`, which is S3's own idempotent behaviour rather than a
+* fiction layered over it.
+*/
+const s3StorageBackend = (client, bucket) => ({
+	put: (key, bytes, options) => (0, unthrown.fromPromise)(client.send(new _aws_sdk_client_s3.PutObjectCommand({
+		Bucket: bucket,
+		Key: key,
+		Body: bytes,
+		ContentType: options.contentType
+	})), (cause) => unavailable("put", key, cause)).map(() => void 0),
+	get: (key) => (0, unthrown.fromPromise)(client.send(new _aws_sdk_client_s3.GetObjectCommand({
+		Bucket: bucket,
+		Key: key
+	})).then(async (response) => ({
+		bytes: await response.Body.transformToByteArray(),
+		contentType: response.ContentType ?? "application/octet-stream"
+	})), (cause) => isMissing(cause) ? new require_storage.ObjectNotFound({ key }) : unavailable("get", key, cause)),
+	delete: (key) => (0, unthrown.fromPromise)(client.send(new _aws_sdk_client_s3.DeleteObjectCommand({
+		Bucket: bucket,
+		Key: key
+	})), (cause) => unavailable("delete", key, cause)).map(() => void 0),
+	presignedUrl: (key, options) => (0, unthrown.fromPromise)((0, _aws_sdk_s3_request_presigner.getSignedUrl)(client, new _aws_sdk_client_s3.GetObjectCommand({
+		Bucket: bucket,
+		Key: key
+	}), { expiresIn: Math.ceil(options.ttlMs / 1e3) }), (cause) => unavailable("presignedUrl", key, cause))
+});
+/**
+* The S3 adapter: one client, built with the scope and destroyed with it, and
+* `StorageBackend` over it. Its two AWS SDK peers are **optional** and reached
+* only through this subpath, so an application composing the memory adapter
+* installs neither.
+*/
+const s3Storage = () => (0, _btravstack_di.Module)("S3Storage")({
+	needs: [_btravstack_config.Env],
+	provides: [
+		_btravstack_config.Config.provider(StorageConfig)(s3Schema),
+		(0, _btravstack_di.Provider)(S3Connection)({ config: StorageConfig }, {
+			acquire: ({ config }) => (0, unthrown.fromSafePromise)(Promise.resolve({
+				client: new _aws_sdk_client_s3.S3Client({
+					endpoint: config.endpoint,
+					region: config.region,
+					forcePathStyle: true,
+					credentials: {
+						accessKeyId: config.accessKeyId,
+						secretAccessKey: config.secretAccessKey
+					}
+				}),
+				bucket: config.bucket
+			})),
+			release: ({ client }) => {
+				client.destroy();
+			}
+		}),
+		(0, _btravstack_di.Provider)(require_storage.StorageBackend)({ connection: S3Connection }, { sync: ({ connection }) => s3StorageBackend(connection.client, connection.bucket) })
+	],
+	exports: [require_storage.StorageBackend]
+});
+//#endregion
+exports.StorageConfig = StorageConfig;
+exports.s3Schema = s3Schema;
+exports.s3Storage = s3Storage;
+exports.s3StorageBackend = s3StorageBackend;

package/dist/s3.d.cts

@@ -0,0 +1,45 @@
+import { a as StorageService, i as StorageBackend } from "./storage-C9j3zj7r.cjs";
+import { Module, Scope } from "@btravstack/di";
+import { S3Client } from "@aws-sdk/client-s3";
+import { ConfigInvalid, Env } from "@btravstack/config";
+//#region src/s3.d.ts
+declare const StorageConfig_base: import("@btravstack/di").PortClass<"StorageConfig">;
+/** What the graph bound from the environment for the S3 adapter. */
+declare class StorageConfig extends StorageConfig_base<{
+  readonly endpoint: string;
+  readonly region: string;
+  readonly bucket: string;
+  readonly accessKeyId: string;
+  readonly secretAccessKey: string;
+}> {}
+/**
+ * The five variables an S3-compatible store needs, and no sixth.
+ *
+ * `STORAGE_S3_ENDPOINT` is required rather than defaulted to AWS: every store
+ * this port exists for has one, and a default pointing at Amazon would be a
+ * surprising bill. **Path-style addressing is not configurable**, it is simply
+ * on — every self-hosted store requires it and AWS accepts it, so it is a value
+ * that never changes.
+ */
+declare const s3Schema: import("@btravstack/config").ConfigSchema<Readonly<Record<string, string | undefined>>, {
+  readonly endpoint: string;
+  readonly region: string;
+  readonly bucket: string;
+  readonly accessKeyId: string;
+  readonly secretAccessKey: string;
+}>;
+/**
+ * The adapter's service over a client and a bucket. A delete of a key nobody
+ * stored answers `Ok`, which is S3's own idempotent behaviour rather than a
+ * fiction layered over it.
+ */
+declare const s3StorageBackend: (client: S3Client, bucket: string) => StorageService;
+/**
+ * The S3 adapter: one client, built with the scope and destroyed with it, and
+ * `StorageBackend` over it. Its two AWS SDK peers are **optional** and reached
+ * only through this subpath, so an application composing the memory adapter
+ * installs neither.
+ */
+declare const s3Storage: () => Module<StorageBackend, ConfigInvalid, Env | Scope>;
+//#endregion
+export { StorageConfig, s3Schema, s3Storage, s3StorageBackend };

package/dist/s3.d.mts

@@ -0,0 +1,45 @@
+import { a as StorageService, i as StorageBackend } from "./storage-C9j3zj7r.mjs";
+import { Module, Scope } from "@btravstack/di";
+import { S3Client } from "@aws-sdk/client-s3";
+import { ConfigInvalid, Env } from "@btravstack/config";
+//#region src/s3.d.ts
+declare const StorageConfig_base: import("@btravstack/di").PortClass<"StorageConfig">;
+/** What the graph bound from the environment for the S3 adapter. */
+declare class StorageConfig extends StorageConfig_base<{
+  readonly endpoint: string;
+  readonly region: string;
+  readonly bucket: string;
+  readonly accessKeyId: string;
+  readonly secretAccessKey: string;
+}> {}
+/**
+ * The five variables an S3-compatible store needs, and no sixth.
+ *
+ * `STORAGE_S3_ENDPOINT` is required rather than defaulted to AWS: every store
+ * this port exists for has one, and a default pointing at Amazon would be a
+ * surprising bill. **Path-style addressing is not configurable**, it is simply
+ * on — every self-hosted store requires it and AWS accepts it, so it is a value
+ * that never changes.
+ */
+declare const s3Schema: import("@btravstack/config").ConfigSchema<Readonly<Record<string, string | undefined>>, {
+  readonly endpoint: string;
+  readonly region: string;
+  readonly bucket: string;
+  readonly accessKeyId: string;
+  readonly secretAccessKey: string;
+}>;
+/**
+ * The adapter's service over a client and a bucket. A delete of a key nobody
+ * stored answers `Ok`, which is S3's own idempotent behaviour rather than a
+ * fiction layered over it.
+ */
+declare const s3StorageBackend: (client: S3Client, bucket: string) => StorageService;
+/**
+ * The S3 adapter: one client, built with the scope and destroyed with it, and
+ * `StorageBackend` over it. Its two AWS SDK peers are **optional** and reached
+ * only through this subpath, so an application composing the memory adapter
+ * installs neither.
+ */
+declare const s3Storage: () => Module<StorageBackend, ConfigInvalid, Env | Scope>;
+//#endregion
+export { StorageConfig, s3Schema, s3Storage, s3StorageBackend };

package/dist/s3.mjs

@@ -0,0 +1,99 @@
+import { a as StorageUnavailable, i as StorageBackend, t as ObjectNotFound } from "./storage-CRkwIhac.mjs";
+import { Module, Port, Provider } from "@btravstack/di";
+import { fromPromise, fromSafePromise } from "unthrown";
+import { DeleteObjectCommand, GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { Config, Env } from "@btravstack/config";
+//#region src/s3.ts
+/** What the graph bound from the environment for the S3 adapter. */
+var StorageConfig = class extends Port("StorageConfig") {};
+/**
+* The five variables an S3-compatible store needs, and no sixth.
+*
+* `STORAGE_S3_ENDPOINT` is required rather than defaulted to AWS: every store
+* this port exists for has one, and a default pointing at Amazon would be a
+* surprising bill. **Path-style addressing is not configurable**, it is simply
+* on — every self-hosted store requires it and AWS accepts it, so it is a value
+* that never changes.
+*/
+const s3Schema = Config.object({
+	endpoint: Config.string("STORAGE_S3_ENDPOINT"),
+	region: Config.string("STORAGE_S3_REGION", { default: "us-east-1" }),
+	bucket: Config.string("STORAGE_S3_BUCKET"),
+	accessKeyId: Config.string("STORAGE_S3_ACCESS_KEY_ID"),
+	secretAccessKey: Config.string("STORAGE_S3_SECRET_ACCESS_KEY")
+});
+/**
+* The client, as a port of its own: a resourceful provider is handed back the
+* service it acquired, and a store's four methods are not something you can
+* close — so the client rides the graph and the scope closing destroys it.
+*/
+var S3Connection = class extends Port("S3Connection") {};
+const unavailable = (operation, key, cause) => new StorageUnavailable({
+	operation,
+	key,
+	reason: cause instanceof Error ? cause.message : String(cause)
+});
+/** A missing key is S3's `NoSuchKey`, which is a different fact from "the store is down". */
+const isMissing = (cause) => cause instanceof Error && (cause.name === "NoSuchKey" || cause.name === "NotFound");
+/**
+* The adapter's service over a client and a bucket. A delete of a key nobody
+* stored answers `Ok`, which is S3's own idempotent behaviour rather than a
+* fiction layered over it.
+*/
+const s3StorageBackend = (client, bucket) => ({
+	put: (key, bytes, options) => fromPromise(client.send(new PutObjectCommand({
+		Bucket: bucket,
+		Key: key,
+		Body: bytes,
+		ContentType: options.contentType
+	})), (cause) => unavailable("put", key, cause)).map(() => void 0),
+	get: (key) => fromPromise(client.send(new GetObjectCommand({
+		Bucket: bucket,
+		Key: key
+	})).then(async (response) => ({
+		bytes: await response.Body.transformToByteArray(),
+		contentType: response.ContentType ?? "application/octet-stream"
+	})), (cause) => isMissing(cause) ? new ObjectNotFound({ key }) : unavailable("get", key, cause)),
+	delete: (key) => fromPromise(client.send(new DeleteObjectCommand({
+		Bucket: bucket,
+		Key: key
+	})), (cause) => unavailable("delete", key, cause)).map(() => void 0),
+	presignedUrl: (key, options) => fromPromise(getSignedUrl(client, new GetObjectCommand({
+		Bucket: bucket,
+		Key: key
+	}), { expiresIn: Math.ceil(options.ttlMs / 1e3) }), (cause) => unavailable("presignedUrl", key, cause))
+});
+/**
+* The S3 adapter: one client, built with the scope and destroyed with it, and
+* `StorageBackend` over it. Its two AWS SDK peers are **optional** and reached
+* only through this subpath, so an application composing the memory adapter
+* installs neither.
+*/
+const s3Storage = () => Module("S3Storage")({
+	needs: [Env],
+	provides: [
+		Config.provider(StorageConfig)(s3Schema),
+		Provider(S3Connection)({ config: StorageConfig }, {
+			acquire: ({ config }) => fromSafePromise(Promise.resolve({
+				client: new S3Client({
+					endpoint: config.endpoint,
+					region: config.region,
+					forcePathStyle: true,
+					credentials: {
+						accessKeyId: config.accessKeyId,
+						secretAccessKey: config.secretAccessKey
+					}
+				}),
+				bucket: config.bucket
+			})),
+			release: ({ client }) => {
+				client.destroy();
+			}
+		}),
+		Provider(StorageBackend)({ connection: S3Connection }, { sync: ({ connection }) => s3StorageBackend(connection.client, connection.bucket) })
+	],
+	exports: [StorageBackend]
+});
+//#endregion
+export { StorageConfig, s3Schema, s3Storage, s3StorageBackend };

package/dist/storage-C9j3zj7r.d.cts

@@ -0,0 +1,61 @@
+import { AsyncResult } from "unthrown";
+//#region src/storage.d.ts
+/** One stored object: its bytes and what they are. */
+type StoredObject = {
+  readonly bytes: Uint8Array;
+  readonly contentType: string;
+};
+declare const ObjectNotFound_base: import("unthrown").TaggedErrorConstructor<"ObjectNotFound">;
+/** The key is not there. Only `get` answers it — see `delete` and `presignedUrl` below. */
+declare class ObjectNotFound extends ObjectNotFound_base<{
+  readonly key: string;
+}> {}
+declare const StorageUnavailable_base: import("unthrown").TaggedErrorConstructor<"StorageUnavailable">;
+/** The store could not answer — the endpoint is down, the credentials were refused, the bucket is gone. */
+declare class StorageUnavailable extends StorageUnavailable_base<{
+  readonly operation: "put" | "get" | "delete" | "presignedUrl";
+  readonly key: string;
+  readonly reason: string;
+}> {}
+declare const PresignNotSupported_base: import("unthrown").TaggedErrorConstructor<"PresignNotSupported">;
+/** The adapter cannot mint a time-limited URL, and says so rather than pretending. */
+declare class PresignNotSupported extends PresignNotSupported_base<{
+  readonly key: string;
+}> {}
+type StorageService = {
+  readonly put: (key: string, bytes: Uint8Array, options: {
+    readonly contentType: string;
+  }) => AsyncResult<void, StorageUnavailable>;
+  readonly get: (key: string) => AsyncResult<StoredObject, ObjectNotFound | StorageUnavailable>;
+  /** Deleting a key nobody stored is `Ok`: delete is idempotent, which is S3's own behaviour rather than a fiction over it. */
+  readonly delete: (key: string) => AsyncResult<void, StorageUnavailable>;
+  /**
+   * A URL that reads the object for `ttlMs`, without the caller holding
+   * credentials.
+   *
+   * There is **no `ObjectNotFound` arm**: presigning is a signature computation
+   * that asks the store nothing, so a URL for an absent key is minted happily
+   * and 404s when followed. Checking would cost a HEAD per call.
+   */
+  readonly presignedUrl: (key: string, options: {
+    readonly ttlMs: number;
+  }) => AsyncResult<string, PresignNotSupported | StorageUnavailable>;
+};
+declare const Storage_base: import("@btravstack/di").PortClass<"Storage">;
+/**
+ * The port an application depends on.
+ *
+ * Keys are plain strings the caller composes, tenant included: a store is an
+ * application service, and the framework has no concept of a tenant to put in a
+ * slot.
+ *
+ * **Bytes, not streams.** An object here is a document. Streaming would change
+ * every signature, adapter and test to serve a case that wants a different
+ * design anyway — a stated non-goal, not an oversight.
+ */
+declare class Storage extends Storage_base<StorageService> {}
+declare const StorageBackend_base: import("@btravstack/di").PortClass<"StorageBackend">;
+/** The port every adapter provides, and the one an application never depends on. */
+declare class StorageBackend extends StorageBackend_base<StorageService> {}
+//#endregion
+export { StorageService as a, StorageBackend as i, PresignNotSupported as n, StorageUnavailable as o, Storage as r, StoredObject as s, ObjectNotFound as t };

package/dist/storage-C9j3zj7r.d.mts

@@ -0,0 +1,61 @@
+import { AsyncResult } from "unthrown";
+//#region src/storage.d.ts
+/** One stored object: its bytes and what they are. */
+type StoredObject = {
+  readonly bytes: Uint8Array;
+  readonly contentType: string;
+};
+declare const ObjectNotFound_base: import("unthrown").TaggedErrorConstructor<"ObjectNotFound">;
+/** The key is not there. Only `get` answers it — see `delete` and `presignedUrl` below. */
+declare class ObjectNotFound extends ObjectNotFound_base<{
+  readonly key: string;
+}> {}
+declare const StorageUnavailable_base: import("unthrown").TaggedErrorConstructor<"StorageUnavailable">;
+/** The store could not answer — the endpoint is down, the credentials were refused, the bucket is gone. */
+declare class StorageUnavailable extends StorageUnavailable_base<{
+  readonly operation: "put" | "get" | "delete" | "presignedUrl";
+  readonly key: string;
+  readonly reason: string;
+}> {}
+declare const PresignNotSupported_base: import("unthrown").TaggedErrorConstructor<"PresignNotSupported">;
+/** The adapter cannot mint a time-limited URL, and says so rather than pretending. */
+declare class PresignNotSupported extends PresignNotSupported_base<{
+  readonly key: string;
+}> {}
+type StorageService = {
+  readonly put: (key: string, bytes: Uint8Array, options: {
+    readonly contentType: string;
+  }) => AsyncResult<void, StorageUnavailable>;
+  readonly get: (key: string) => AsyncResult<StoredObject, ObjectNotFound | StorageUnavailable>;
+  /** Deleting a key nobody stored is `Ok`: delete is idempotent, which is S3's own behaviour rather than a fiction over it. */
+  readonly delete: (key: string) => AsyncResult<void, StorageUnavailable>;
+  /**
+   * A URL that reads the object for `ttlMs`, without the caller holding
+   * credentials.
+   *
+   * There is **no `ObjectNotFound` arm**: presigning is a signature computation
+   * that asks the store nothing, so a URL for an absent key is minted happily
+   * and 404s when followed. Checking would cost a HEAD per call.
+   */
+  readonly presignedUrl: (key: string, options: {
+    readonly ttlMs: number;
+  }) => AsyncResult<string, PresignNotSupported | StorageUnavailable>;
+};
+declare const Storage_base: import("@btravstack/di").PortClass<"Storage">;
+/**
+ * The port an application depends on.
+ *
+ * Keys are plain strings the caller composes, tenant included: a store is an
+ * application service, and the framework has no concept of a tenant to put in a
+ * slot.
+ *
+ * **Bytes, not streams.** An object here is a document. Streaming would change
+ * every signature, adapter and test to serve a case that wants a different
+ * design anyway — a stated non-goal, not an oversight.
+ */
+declare class Storage extends Storage_base<StorageService> {}
+declare const StorageBackend_base: import("@btravstack/di").PortClass<"StorageBackend">;
+/** The port every adapter provides, and the one an application never depends on. */
+declare class StorageBackend extends StorageBackend_base<StorageService> {}
+//#endregion
+export { StorageService as a, StorageBackend as i, PresignNotSupported as n, StorageUnavailable as o, Storage as r, StoredObject as s, ObjectNotFound as t };

package/dist/storage-CRkwIhac.mjs

@@ -0,0 +1,25 @@
+import { Port } from "@btravstack/di";
+import { TaggedError } from "unthrown";
+//#region src/storage.ts
+/** The key is not there. Only `get` answers it — see `delete` and `presignedUrl` below. */
+var ObjectNotFound = class extends TaggedError("ObjectNotFound") {};
+/** The store could not answer — the endpoint is down, the credentials were refused, the bucket is gone. */
+var StorageUnavailable = class extends TaggedError("StorageUnavailable") {};
+/** The adapter cannot mint a time-limited URL, and says so rather than pretending. */
+var PresignNotSupported = class extends TaggedError("PresignNotSupported") {};
+/**
+* The port an application depends on.
+*
+* Keys are plain strings the caller composes, tenant included: a store is an
+* application service, and the framework has no concept of a tenant to put in a
+* slot.
+*
+* **Bytes, not streams.** An object here is a document. Streaming would change
+* every signature, adapter and test to serve a case that wants a different
+* design anyway — a stated non-goal, not an oversight.
+*/
+var Storage = class extends Port("Storage") {};
+/** The port every adapter provides, and the one an application never depends on. */
+var StorageBackend = class extends Port("StorageBackend") {};
+//#endregion
+export { StorageUnavailable as a, StorageBackend as i, PresignNotSupported as n, Storage as r, ObjectNotFound as t };

package/dist/storage-QVPXOcO6.cjs

@@ -0,0 +1,54 @@
+let _btravstack_di = require("@btravstack/di");
+let unthrown = require("unthrown");
+//#region src/storage.ts
+/** The key is not there. Only `get` answers it — see `delete` and `presignedUrl` below. */
+var ObjectNotFound = class extends (0, unthrown.TaggedError)("ObjectNotFound") {};
+/** The store could not answer — the endpoint is down, the credentials were refused, the bucket is gone. */
+var StorageUnavailable = class extends (0, unthrown.TaggedError)("StorageUnavailable") {};
+/** The adapter cannot mint a time-limited URL, and says so rather than pretending. */
+var PresignNotSupported = class extends (0, unthrown.TaggedError)("PresignNotSupported") {};
+/**
+* The port an application depends on.
+*
+* Keys are plain strings the caller composes, tenant included: a store is an
+* application service, and the framework has no concept of a tenant to put in a
+* slot.
+*
+* **Bytes, not streams.** An object here is a document. Streaming would change
+* every signature, adapter and test to serve a case that wants a different
+* design anyway — a stated non-goal, not an oversight.
+*/
+var Storage = class extends (0, _btravstack_di.Port)("Storage") {};
+/** The port every adapter provides, and the one an application never depends on. */
+var StorageBackend = class extends (0, _btravstack_di.Port)("StorageBackend") {};
+//#endregion
+Object.defineProperty(exports, "ObjectNotFound", {
+	enumerable: true,
+	get: function() {
+		return ObjectNotFound;
+	}
+});
+Object.defineProperty(exports, "PresignNotSupported", {
+	enumerable: true,
+	get: function() {
+		return PresignNotSupported;
+	}
+});
+Object.defineProperty(exports, "Storage", {
+	enumerable: true,
+	get: function() {
+		return Storage;
+	}
+});
+Object.defineProperty(exports, "StorageBackend", {
+	enumerable: true,
+	get: function() {
+		return StorageBackend;
+	}
+});
+Object.defineProperty(exports, "StorageUnavailable", {
+	enumerable: true,
+	get: function() {
+		return StorageUnavailable;
+	}
+});

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@btravstack/storage",
+  "version": "0.3.0",
+  "description": "A Storage port for @btravstack/core: an in-memory adapter, an S3-compatible adapter with presigned reads, and a composition that spans, counts and logs every operation",
+  "keywords": [
+    "dependency-injection",
+    "object-storage",
+    "s3",
+    "storage",
+    "typescript",
+    "unthrown"
+  ],
+  "homepage": "https://github.com/btravstack/btravstack#readme",
+  "bugs": {
+    "url": "https://github.com/btravstack/btravstack/issues"
+  },
+  "license": "MIT",
+  "author": "Benoit TRAVERS <benoit.travers.fr@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/btravstack/btravstack.git",
+    "directory": "packages/storage"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./s3": {
+      "import": {
+        "types": "./dist/s3.d.mts",
+        "default": "./dist/s3.mjs"
+      },
+      "require": {
+        "types": "./dist/s3.d.cts",
+        "default": "./dist/s3.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-s3": "3.1117.0",
+    "@aws-sdk/s3-request-presigner": "3.1117.0",
+    "@btravstack/tsconfig": "0.2.0",
+    "@opentelemetry/api": "1.9.1",
+    "@opentelemetry/sdk-metrics": "2.10.0",
+    "@opentelemetry/sdk-node": "0.221.0",
+    "@opentelemetry/sdk-trace": "2.10.0",
+    "@types/node": "26.2.0",
+    "@unthrown/vitest": "5.7.0",
+    "@vitest/coverage-v8": "4.1.11",
+    "tsdown": "0.22.14",
+    "typescript": "7.0.2",
+    "unthrown": "5.7.0",
+    "vitest": "4.1.11",
+    "@btravstack/config": "0.3.0",
+    "@btravstack/internal-test-infra": "0.0.0",
+    "@btravstack/core": "0.3.0",
+    "@btravstack/observability": "0.3.0",
+    "@btravstack/di": "0.3.0"
+  },
+  "peerDependencies": {
+    "@aws-sdk/client-s3": "^3.1000.0",
+    "@aws-sdk/s3-request-presigner": "^3.1000.0",
+    "unthrown": "^5.0.0",
+    "@btravstack/config": "^0.3.0",
+    "@btravstack/di": "^0.3.0",
+    "@btravstack/core": "^0.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@aws-sdk/client-s3": {
+      "optional": true
+    },
+    "@aws-sdk/s3-request-presigner": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts src/s3.ts --format cjs,esm --dts --clean",
+    "dev": "tsdown src/index.ts src/s3.ts --format cjs,esm --dts --watch",
+    "test": "vitest run --coverage",
+    "test:types": "tsc -p tsconfig.test-d.json --noEmit",
+    "typecheck": "tsc --noEmit"
+  }
+}