@ai-digital-factory/asset-manager 0.1.0

package/dist/index.cjs

@@ -0,0 +1,399 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AssetManagerError: () => AssetManagerError,
+  createAssetManager: () => createAssetManager
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../r2/dist/index.js
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_stream = require("stream");
+var import_client_s3 = require("@aws-sdk/client-s3");
+var import_lib_storage = require("@aws-sdk/lib-storage");
+var import_mime_types = require("mime-types");
+var R2AssetManagerError = class extends Error {
+  code;
+  retryable;
+  constructor(code, message, retryable, options) {
+    super(message, options);
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "R2AssetManagerError";
+  }
+};
+var PUBLIC_BASE_URL = "https://pub-b3f9537bf89843aebcb0730a735af9b2.r2.dev";
+var DEFAULT_PART_SIZE = 5 * 1024 * 1024;
+var DEFAULT_QUEUE_SIZE = 4;
+var CREDENTIAL_PREFIX = "am_v1.";
+var MEDIA_TYPE = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+(?:\s*;\s*[!#$%&'*+.^_`|~0-9A-Za-z-]+=(?:[!#$%&'*+.^_`|~0-9A-Za-z-]+|"(?:[^"\\]|\\.)*"))*$/u;
+function invalidArgument(message) {
+  throw new R2AssetManagerError("INVALID_ARGUMENT", message, false);
+}
+function hasControlCharacter(value) {
+  return [...value].some((character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint <= 31 || codePoint === 127;
+  });
+}
+function invalidCredential() {
+  throw new Error("Invalid Asset Manager Credential");
+}
+function isR2CredentialConfig(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  const expectedKeys = [
+    "accessKeyId",
+    "accountId",
+    "bucket",
+    "secretAccessKey"
+  ];
+  if (Object.keys(record).sort().join(",") !== expectedKeys.join(",")) {
+    return false;
+  }
+  return expectedKeys.every((key) => typeof record[key] === "string" && record[key].length > 0);
+}
+function decodeR2Credential(credential) {
+  try {
+    if (!credential.startsWith(CREDENTIAL_PREFIX)) {
+      invalidCredential();
+    }
+    const payload = credential.slice(CREDENTIAL_PREFIX.length);
+    if (payload.length === 0 || !/^[A-Za-z0-9_-]+$/u.test(payload) || Buffer.from(payload, "base64url").toString("base64url") !== payload) {
+      invalidCredential();
+    }
+    const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    if (!isR2CredentialConfig(decoded)) {
+      invalidCredential();
+    }
+    return decoded;
+  } catch {
+    invalidCredential();
+  }
+}
+function validateNamespace(namespace) {
+  if (namespace.length === 0 || namespace === "." || namespace === ".." || Buffer.byteLength(namespace, "utf8") > 128 || namespace.includes("/") || namespace.includes("\\") || hasControlCharacter(namespace)) {
+    invalidArgument("Namespace must be one valid name of at most 128 bytes");
+  }
+}
+function validateLogicalPath(value, label) {
+  const segments = value.split("/");
+  if (value.length === 0 || Buffer.byteLength(value, "utf8") > 1024 || value.includes("\\") || hasControlCharacter(value) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    invalidArgument(`${label} must be a valid relative logical path`);
+  }
+}
+function validateContentType(contentType) {
+  if (!MEDIA_TYPE.test(contentType)) {
+    invalidArgument("Content type must be a valid media type");
+  }
+}
+function validateContentLength(contentLength) {
+  if (!Number.isSafeInteger(contentLength) || contentLength < 0) {
+    invalidArgument("Content length must be a non-negative safe integer");
+  }
+}
+function createR2Client(config, client) {
+  return client ?? new import_client_s3.S3Client({
+    region: "auto",
+    endpoint: `https://${config.accountId}.r2.cloudflarestorage.com`,
+    credentials: {
+      accessKeyId: config.accessKeyId,
+      secretAccessKey: config.secretAccessKey
+    }
+  });
+}
+function contentTypeFor(assetPath) {
+  return (0, import_mime_types.lookup)(assetPath) || "application/octet-stream";
+}
+function normalizeBody(body) {
+  if (body instanceof Uint8Array || body instanceof import_node_stream.Readable) {
+    return body;
+  }
+  return import_node_stream.Readable.fromWeb(body);
+}
+function lengthMismatch(expected, actual) {
+  return new R2AssetManagerError("LENGTH_MISMATCH", `Body length ${actual} does not match declared content length ${expected}`, false);
+}
+function aborted(cause) {
+  return new R2AssetManagerError("ABORTED", "Asset Manager operation was aborted", false, cause === void 0 ? void 0 : { cause });
+}
+function createMeteredBody(body, expectedLength) {
+  if (body instanceof Uint8Array) {
+    if (body.byteLength !== expectedLength) {
+      throw lengthMismatch(expectedLength, body.byteLength);
+    }
+    return { body };
+  }
+  const source = normalizeBody(body);
+  let sourceError;
+  let actualLength = 0;
+  const meter = new import_node_stream.Transform({
+    writableObjectMode: true,
+    transform(chunk, _encoding, callback) {
+      if (!(chunk instanceof Uint8Array)) {
+        callback(new R2AssetManagerError("INVALID_ARGUMENT", "Body streams must emit only Uint8Array chunks", false));
+        return;
+      }
+      actualLength += chunk.byteLength;
+      if (actualLength > expectedLength) {
+        callback(lengthMismatch(expectedLength, actualLength));
+        return;
+      }
+      callback(null, chunk);
+    },
+    flush(callback) {
+      if (actualLength !== expectedLength) {
+        callback(lengthMismatch(expectedLength, actualLength));
+        return;
+      }
+      callback();
+    }
+  });
+  source.once("error", (error) => {
+    sourceError = error;
+    meter.destroy(error);
+  });
+  return {
+    body: source.pipe(meter),
+    source,
+    sourceFailure: () => sourceError
+  };
+}
+function isAuthorizationError(error) {
+  return error instanceof Error && [
+    "AccessDenied",
+    "CredentialsProviderError",
+    "ExpiredToken",
+    "InvalidAccessKeyId",
+    "SignatureDoesNotMatch"
+  ].includes(error.name);
+}
+function encodePath(path) {
+  return path.split("/").map(encodeURIComponent).join("/");
+}
+var R2AssetManager = class {
+  bucket;
+  client;
+  namespace;
+  constructor(config, deps = {}) {
+    validateNamespace(config.namespace);
+    this.bucket = config.bucket;
+    this.client = createR2Client(config, deps.client);
+    this.namespace = config.namespace;
+  }
+  async publish(input) {
+    validateLogicalPath(input.assetPath, "Asset Path");
+    if (input.signal?.aborted) {
+      throw aborted(input.signal.reason);
+    }
+    let fileStat;
+    try {
+      fileStat = await (0, import_promises.stat)(input.localPath);
+    } catch (error) {
+      throw new R2AssetManagerError("SOURCE_UNAVAILABLE", "Local Asset is unavailable", false, { cause: error });
+    }
+    if (!fileStat.isFile()) {
+      throw new R2AssetManagerError("SOURCE_UNAVAILABLE", "Local Asset must be a regular file", false);
+    }
+    const providerKey = `assets/${this.namespace}/${input.assetPath}`;
+    await this.upload({
+      key: providerKey,
+      body: (0, import_node_fs.createReadStream)(input.localPath),
+      contentType: contentTypeFor(input.assetPath),
+      contentLength: fileStat.size,
+      signal: input.signal
+    });
+    return `${PUBLIC_BASE_URL}/${encodePath(providerKey)}`;
+  }
+  async put(input) {
+    validateLogicalPath(input.key, "Object Key");
+    validateContentType(input.contentType);
+    validateContentLength(input.contentLength);
+    await this.upload({
+      key: `objects/${this.namespace}/${input.key}`,
+      body: input.body,
+      contentType: input.contentType,
+      contentLength: input.contentLength,
+      signal: input.signal
+    });
+  }
+  async upload(input) {
+    if (input.signal?.aborted) {
+      throw aborted(input.signal.reason);
+    }
+    const metered = createMeteredBody(input.body, input.contentLength);
+    const upload = new import_lib_storage.Upload({
+      client: this.client,
+      params: {
+        Bucket: this.bucket,
+        Key: input.key,
+        Body: metered.body,
+        ContentType: input.contentType,
+        ContentLength: input.contentLength
+      },
+      queueSize: DEFAULT_QUEUE_SIZE,
+      partSize: DEFAULT_PART_SIZE,
+      leavePartsOnError: false
+    });
+    let wasAborted = false;
+    const abortUpload = () => {
+      wasAborted = true;
+      metered.source?.destroy();
+      void upload.abort();
+    };
+    input.signal?.addEventListener("abort", abortUpload, { once: true });
+    try {
+      await upload.done();
+    } catch (error) {
+      metered.source?.destroy();
+      if (wasAborted || input.signal?.aborted) {
+        throw aborted(error);
+      }
+      if (error instanceof R2AssetManagerError) {
+        throw error;
+      }
+      if (metered.sourceFailure?.() !== void 0) {
+        throw new R2AssetManagerError("SOURCE_UNAVAILABLE", "Object body became unavailable", false, { cause: metered.sourceFailure?.() });
+      }
+      if (isAuthorizationError(error)) {
+        throw new R2AssetManagerError("UNAUTHORIZED", "Asset Manager Credential is not authorized for storage", false, { cause: error });
+      }
+      throw new R2AssetManagerError("WRITE_FAILED", "Provider could not complete the write", true, { cause: error });
+    } finally {
+      input.signal?.removeEventListener("abort", abortUpload);
+    }
+  }
+};
+
+// src/index.ts
+var AssetManagerError = class extends Error {
+  constructor(code, message, retryable, options) {
+    super(message, options);
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "AssetManagerError";
+  }
+  code;
+  retryable;
+};
+function sanitizedCause(error, secrets) {
+  if (!(error instanceof Error)) {
+    return void 0;
+  }
+  let message = error.message;
+  for (const secret of secrets) {
+    if (secret.length > 0) {
+      message = message.replaceAll(secret, "[REDACTED]");
+    }
+  }
+  const cause = new Error(message);
+  cause.name = error.name;
+  return cause;
+}
+function normalizeError(error, secrets) {
+  if (error instanceof AssetManagerError) {
+    return error;
+  }
+  if (error instanceof R2AssetManagerError) {
+    return new AssetManagerError(error.code, error.message, error.retryable, {
+      cause: sanitizedCause(error.cause ?? error, secrets)
+    });
+  }
+  return new AssetManagerError(
+    "WRITE_FAILED",
+    "Asset Manager could not complete the write",
+    true,
+    { cause: sanitizedCause(error, secrets) }
+  );
+}
+var FacadeAssetManager = class {
+  constructor(provider, secrets) {
+    this.provider = provider;
+    this.secrets = secrets;
+  }
+  provider;
+  secrets;
+  async publish(input) {
+    try {
+      return await this.provider.publish(input);
+    } catch (error) {
+      throw normalizeError(error, this.secrets);
+    }
+  }
+  async put(input) {
+    try {
+      await this.provider.put(input);
+    } catch (error) {
+      throw normalizeError(error, this.secrets);
+    }
+  }
+};
+function createAssetManager(input) {
+  if (typeof input?.credential !== "string") {
+    throw new AssetManagerError(
+      "INVALID_CREDENTIAL",
+      "Invalid Asset Manager Credential",
+      false
+    );
+  }
+  if (typeof input.namespace !== "string") {
+    throw new AssetManagerError(
+      "INVALID_ARGUMENT",
+      "Namespace must be one valid name of at most 128 bytes",
+      false
+    );
+  }
+  let config;
+  try {
+    config = decodeR2Credential(input.credential);
+  } catch {
+    throw new AssetManagerError(
+      "INVALID_CREDENTIAL",
+      "Invalid Asset Manager Credential",
+      false
+    );
+  }
+  const secrets = [
+    input.credential,
+    config.accountId,
+    config.accessKeyId,
+    config.secretAccessKey,
+    config.bucket
+  ];
+  try {
+    const provider = new R2AssetManager({
+      ...config,
+      namespace: input.namespace
+    });
+    return new FacadeAssetManager(provider, secrets);
+  } catch (error) {
+    throw normalizeError(error, secrets);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssetManagerError,
+  createAssetManager
+});

package/dist/index.d.cts

@@ -0,0 +1,29 @@
+import { Readable } from 'node:stream';
+
+interface AssetManager {
+    publish(input: {
+        localPath: string;
+        assetPath: string;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    put(input: {
+        key: string;
+        body: Uint8Array | Readable | ReadableStream<Uint8Array>;
+        contentType: string;
+        contentLength: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+
+type AssetManagerErrorCode = "INVALID_ARGUMENT" | "INVALID_CREDENTIAL" | "SOURCE_UNAVAILABLE" | "LENGTH_MISMATCH" | "UNAUTHORIZED" | "ABORTED" | "WRITE_FAILED";
+declare class AssetManagerError extends Error {
+    readonly code: AssetManagerErrorCode;
+    readonly retryable: boolean;
+    constructor(code: AssetManagerErrorCode, message: string, retryable: boolean, options?: ErrorOptions);
+}
+declare function createAssetManager(input: {
+    credential: string;
+    namespace: string;
+}): AssetManager;
+
+export { type AssetManager, AssetManagerError, createAssetManager };

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { Readable } from 'node:stream';
+
+interface AssetManager {
+    publish(input: {
+        localPath: string;
+        assetPath: string;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    put(input: {
+        key: string;
+        body: Uint8Array | Readable | ReadableStream<Uint8Array>;
+        contentType: string;
+        contentLength: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+
+type AssetManagerErrorCode = "INVALID_ARGUMENT" | "INVALID_CREDENTIAL" | "SOURCE_UNAVAILABLE" | "LENGTH_MISMATCH" | "UNAUTHORIZED" | "ABORTED" | "WRITE_FAILED";
+declare class AssetManagerError extends Error {
+    readonly code: AssetManagerErrorCode;
+    readonly retryable: boolean;
+    constructor(code: AssetManagerErrorCode, message: string, retryable: boolean, options?: ErrorOptions);
+}
+declare function createAssetManager(input: {
+    credential: string;
+    namespace: string;
+}): AssetManager;
+
+export { type AssetManager, AssetManagerError, createAssetManager };

package/dist/index.js

@@ -0,0 +1,371 @@
+// ../r2/dist/index.js
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
+import { Readable, Transform } from "stream";
+import { S3Client } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import { lookup } from "mime-types";
+var R2AssetManagerError = class extends Error {
+  code;
+  retryable;
+  constructor(code, message, retryable, options) {
+    super(message, options);
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "R2AssetManagerError";
+  }
+};
+var PUBLIC_BASE_URL = "https://pub-b3f9537bf89843aebcb0730a735af9b2.r2.dev";
+var DEFAULT_PART_SIZE = 5 * 1024 * 1024;
+var DEFAULT_QUEUE_SIZE = 4;
+var CREDENTIAL_PREFIX = "am_v1.";
+var MEDIA_TYPE = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+(?:\s*;\s*[!#$%&'*+.^_`|~0-9A-Za-z-]+=(?:[!#$%&'*+.^_`|~0-9A-Za-z-]+|"(?:[^"\\]|\\.)*"))*$/u;
+function invalidArgument(message) {
+  throw new R2AssetManagerError("INVALID_ARGUMENT", message, false);
+}
+function hasControlCharacter(value) {
+  return [...value].some((character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint <= 31 || codePoint === 127;
+  });
+}
+function invalidCredential() {
+  throw new Error("Invalid Asset Manager Credential");
+}
+function isR2CredentialConfig(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  const expectedKeys = [
+    "accessKeyId",
+    "accountId",
+    "bucket",
+    "secretAccessKey"
+  ];
+  if (Object.keys(record).sort().join(",") !== expectedKeys.join(",")) {
+    return false;
+  }
+  return expectedKeys.every((key) => typeof record[key] === "string" && record[key].length > 0);
+}
+function decodeR2Credential(credential) {
+  try {
+    if (!credential.startsWith(CREDENTIAL_PREFIX)) {
+      invalidCredential();
+    }
+    const payload = credential.slice(CREDENTIAL_PREFIX.length);
+    if (payload.length === 0 || !/^[A-Za-z0-9_-]+$/u.test(payload) || Buffer.from(payload, "base64url").toString("base64url") !== payload) {
+      invalidCredential();
+    }
+    const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    if (!isR2CredentialConfig(decoded)) {
+      invalidCredential();
+    }
+    return decoded;
+  } catch {
+    invalidCredential();
+  }
+}
+function validateNamespace(namespace) {
+  if (namespace.length === 0 || namespace === "." || namespace === ".." || Buffer.byteLength(namespace, "utf8") > 128 || namespace.includes("/") || namespace.includes("\\") || hasControlCharacter(namespace)) {
+    invalidArgument("Namespace must be one valid name of at most 128 bytes");
+  }
+}
+function validateLogicalPath(value, label) {
+  const segments = value.split("/");
+  if (value.length === 0 || Buffer.byteLength(value, "utf8") > 1024 || value.includes("\\") || hasControlCharacter(value) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    invalidArgument(`${label} must be a valid relative logical path`);
+  }
+}
+function validateContentType(contentType) {
+  if (!MEDIA_TYPE.test(contentType)) {
+    invalidArgument("Content type must be a valid media type");
+  }
+}
+function validateContentLength(contentLength) {
+  if (!Number.isSafeInteger(contentLength) || contentLength < 0) {
+    invalidArgument("Content length must be a non-negative safe integer");
+  }
+}
+function createR2Client(config, client) {
+  return client ?? new S3Client({
+    region: "auto",
+    endpoint: `https://${config.accountId}.r2.cloudflarestorage.com`,
+    credentials: {
+      accessKeyId: config.accessKeyId,
+      secretAccessKey: config.secretAccessKey
+    }
+  });
+}
+function contentTypeFor(assetPath) {
+  return lookup(assetPath) || "application/octet-stream";
+}
+function normalizeBody(body) {
+  if (body instanceof Uint8Array || body instanceof Readable) {
+    return body;
+  }
+  return Readable.fromWeb(body);
+}
+function lengthMismatch(expected, actual) {
+  return new R2AssetManagerError("LENGTH_MISMATCH", `Body length ${actual} does not match declared content length ${expected}`, false);
+}
+function aborted(cause) {
+  return new R2AssetManagerError("ABORTED", "Asset Manager operation was aborted", false, cause === void 0 ? void 0 : { cause });
+}
+function createMeteredBody(body, expectedLength) {
+  if (body instanceof Uint8Array) {
+    if (body.byteLength !== expectedLength) {
+      throw lengthMismatch(expectedLength, body.byteLength);
+    }
+    return { body };
+  }
+  const source = normalizeBody(body);
+  let sourceError;
+  let actualLength = 0;
+  const meter = new Transform({
+    writableObjectMode: true,
+    transform(chunk, _encoding, callback) {
+      if (!(chunk instanceof Uint8Array)) {
+        callback(new R2AssetManagerError("INVALID_ARGUMENT", "Body streams must emit only Uint8Array chunks", false));
+        return;
+      }
+      actualLength += chunk.byteLength;
+      if (actualLength > expectedLength) {
+        callback(lengthMismatch(expectedLength, actualLength));
+        return;
+      }
+      callback(null, chunk);
+    },
+    flush(callback) {
+      if (actualLength !== expectedLength) {
+        callback(lengthMismatch(expectedLength, actualLength));
+        return;
+      }
+      callback();
+    }
+  });
+  source.once("error", (error) => {
+    sourceError = error;
+    meter.destroy(error);
+  });
+  return {
+    body: source.pipe(meter),
+    source,
+    sourceFailure: () => sourceError
+  };
+}
+function isAuthorizationError(error) {
+  return error instanceof Error && [
+    "AccessDenied",
+    "CredentialsProviderError",
+    "ExpiredToken",
+    "InvalidAccessKeyId",
+    "SignatureDoesNotMatch"
+  ].includes(error.name);
+}
+function encodePath(path) {
+  return path.split("/").map(encodeURIComponent).join("/");
+}
+var R2AssetManager = class {
+  bucket;
+  client;
+  namespace;
+  constructor(config, deps = {}) {
+    validateNamespace(config.namespace);
+    this.bucket = config.bucket;
+    this.client = createR2Client(config, deps.client);
+    this.namespace = config.namespace;
+  }
+  async publish(input) {
+    validateLogicalPath(input.assetPath, "Asset Path");
+    if (input.signal?.aborted) {
+      throw aborted(input.signal.reason);
+    }
+    let fileStat;
+    try {
+      fileStat = await stat(input.localPath);
+    } catch (error) {
+      throw new R2AssetManagerError("SOURCE_UNAVAILABLE", "Local Asset is unavailable", false, { cause: error });
+    }
+    if (!fileStat.isFile()) {
+      throw new R2AssetManagerError("SOURCE_UNAVAILABLE", "Local Asset must be a regular file", false);
+    }
+    const providerKey = `assets/${this.namespace}/${input.assetPath}`;
+    await this.upload({
+      key: providerKey,
+      body: createReadStream(input.localPath),
+      contentType: contentTypeFor(input.assetPath),
+      contentLength: fileStat.size,
+      signal: input.signal
+    });
+    return `${PUBLIC_BASE_URL}/${encodePath(providerKey)}`;
+  }
+  async put(input) {
+    validateLogicalPath(input.key, "Object Key");
+    validateContentType(input.contentType);
+    validateContentLength(input.contentLength);
+    await this.upload({
+      key: `objects/${this.namespace}/${input.key}`,
+      body: input.body,
+      contentType: input.contentType,
+      contentLength: input.contentLength,
+      signal: input.signal
+    });
+  }
+  async upload(input) {
+    if (input.signal?.aborted) {
+      throw aborted(input.signal.reason);
+    }
+    const metered = createMeteredBody(input.body, input.contentLength);
+    const upload = new Upload({
+      client: this.client,
+      params: {
+        Bucket: this.bucket,
+        Key: input.key,
+        Body: metered.body,
+        ContentType: input.contentType,
+        ContentLength: input.contentLength
+      },
+      queueSize: DEFAULT_QUEUE_SIZE,
+      partSize: DEFAULT_PART_SIZE,
+      leavePartsOnError: false
+    });
+    let wasAborted = false;
+    const abortUpload = () => {
+      wasAborted = true;
+      metered.source?.destroy();
+      void upload.abort();
+    };
+    input.signal?.addEventListener("abort", abortUpload, { once: true });
+    try {
+      await upload.done();
+    } catch (error) {
+      metered.source?.destroy();
+      if (wasAborted || input.signal?.aborted) {
+        throw aborted(error);
+      }
+      if (error instanceof R2AssetManagerError) {
+        throw error;
+      }
+      if (metered.sourceFailure?.() !== void 0) {
+        throw new R2AssetManagerError("SOURCE_UNAVAILABLE", "Object body became unavailable", false, { cause: metered.sourceFailure?.() });
+      }
+      if (isAuthorizationError(error)) {
+        throw new R2AssetManagerError("UNAUTHORIZED", "Asset Manager Credential is not authorized for storage", false, { cause: error });
+      }
+      throw new R2AssetManagerError("WRITE_FAILED", "Provider could not complete the write", true, { cause: error });
+    } finally {
+      input.signal?.removeEventListener("abort", abortUpload);
+    }
+  }
+};
+
+// src/index.ts
+var AssetManagerError = class extends Error {
+  constructor(code, message, retryable, options) {
+    super(message, options);
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "AssetManagerError";
+  }
+  code;
+  retryable;
+};
+function sanitizedCause(error, secrets) {
+  if (!(error instanceof Error)) {
+    return void 0;
+  }
+  let message = error.message;
+  for (const secret of secrets) {
+    if (secret.length > 0) {
+      message = message.replaceAll(secret, "[REDACTED]");
+    }
+  }
+  const cause = new Error(message);
+  cause.name = error.name;
+  return cause;
+}
+function normalizeError(error, secrets) {
+  if (error instanceof AssetManagerError) {
+    return error;
+  }
+  if (error instanceof R2AssetManagerError) {
+    return new AssetManagerError(error.code, error.message, error.retryable, {
+      cause: sanitizedCause(error.cause ?? error, secrets)
+    });
+  }
+  return new AssetManagerError(
+    "WRITE_FAILED",
+    "Asset Manager could not complete the write",
+    true,
+    { cause: sanitizedCause(error, secrets) }
+  );
+}
+var FacadeAssetManager = class {
+  constructor(provider, secrets) {
+    this.provider = provider;
+    this.secrets = secrets;
+  }
+  provider;
+  secrets;
+  async publish(input) {
+    try {
+      return await this.provider.publish(input);
+    } catch (error) {
+      throw normalizeError(error, this.secrets);
+    }
+  }
+  async put(input) {
+    try {
+      await this.provider.put(input);
+    } catch (error) {
+      throw normalizeError(error, this.secrets);
+    }
+  }
+};
+function createAssetManager(input) {
+  if (typeof input?.credential !== "string") {
+    throw new AssetManagerError(
+      "INVALID_CREDENTIAL",
+      "Invalid Asset Manager Credential",
+      false
+    );
+  }
+  if (typeof input.namespace !== "string") {
+    throw new AssetManagerError(
+      "INVALID_ARGUMENT",
+      "Namespace must be one valid name of at most 128 bytes",
+      false
+    );
+  }
+  let config;
+  try {
+    config = decodeR2Credential(input.credential);
+  } catch {
+    throw new AssetManagerError(
+      "INVALID_CREDENTIAL",
+      "Invalid Asset Manager Credential",
+      false
+    );
+  }
+  const secrets = [
+    input.credential,
+    config.accountId,
+    config.accessKeyId,
+    config.secretAccessKey,
+    config.bucket
+  ];
+  try {
+    const provider = new R2AssetManager({
+      ...config,
+      namespace: input.namespace
+    });
+    return new FacadeAssetManager(provider, secrets);
+  } catch (error) {
+    throw normalizeError(error, secrets);
+  }
+}
+export {
+  AssetManagerError,
+  createAssetManager
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@ai-digital-factory/asset-manager",
+  "version": "0.1.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ai-digital-factory/asset-manager"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "3.1098.0",
+    "@aws-sdk/lib-storage": "3.1098.0",
+    "mime-types": "^3.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.17.2",
+    "tsup": "^8.5.0",
+    "@ai-digital-factory/asset-manager-core": "0.0.2",
+    "@ai-digital-factory/asset-manager-r2": "0.0.2"
+  },
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "test": "vitest run",
+    "typecheck": "tsc --project tsconfig.json",
+    "lint": "eslint . --ext ts"
+  }
+}