@credo-ts/react-native 0.6.0-alpha-20251010154241 → 0.6.0-alpha-20251010164336

package/build/ReactNativeFileSystem.js

@@ -1,113 +1,73 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReactNativeFileSystem = void 0;
-const core_1 = require("@credo-ts/core");
-const react_native_1 = require("react-native");
-const RNFS = __importStar(require("react-native-fs"));
-class ReactNativeFileSystem {
-    /**
-     * Create new ReactNativeFileSystem class instance.
-     *
-     * @param baseDataPath The base path to use for reading and writing data files used within the framework.
-     * Files will be created under baseDataPath/.afj directory. If not specified, it will be set to
-     * RNFS.DocumentDirectoryPath
-     * @param baseCachePath The base path to use for reading and writing cache files used within the framework.
-     * Files will be created under baseCachePath/.afj directory. If not specified, it will be set to
-     * RNFS.CachesDirectoryPath
-     * @param baseTempPath The base path to use for reading and writing temporary files within the framework.
-     * Files will be created under baseTempPath/.afj directory. If not specified, it will be set to
-     * RNFS.TemporaryDirectoryPath
-     *
-     * @see https://github.com/itinance/react-native-fs#constants
-     */
-    constructor(options) {
-        this.dataPath = `${options?.baseDataPath ?? RNFS.DocumentDirectoryPath}/.afj`;
-        // In Android, TemporaryDirectoryPath falls back to CachesDirectoryPath
-        this.cachePath = options?.baseCachePath
-            ? `${options?.baseCachePath}/.afj`
-            : `${RNFS.CachesDirectoryPath}/.afj${react_native_1.Platform.OS === 'android' ? '/cache' : ''}`;
-        this.tempPath = options?.baseTempPath
-            ? `${options?.baseTempPath}/.afj`
-            : `${RNFS.TemporaryDirectoryPath}/.afj${react_native_1.Platform.OS === 'android' ? '/temp' : ''}`;
-    }
-    async exists(path) {
-        return RNFS.exists(path);
-    }
-    async createDirectory(path) {
-        await RNFS.mkdir((0, core_1.getDirFromFilePath)(path));
-    }
-    async copyFile(sourcePath, destinationPath) {
-        await RNFS.copyFile(sourcePath, destinationPath);
-    }
-    async write(path, data) {
-        // Make sure parent directories exist
-        await RNFS.mkdir((0, core_1.getDirFromFilePath)(path));
-        return RNFS.writeFile(path, data, 'utf8');
-    }
-    async read(path) {
-        return RNFS.readFile(path, 'utf8');
-    }
-    async delete(path) {
-        await RNFS.unlink(path);
-    }
-    async downloadToFile(url, path, options) {
-        // Make sure parent directories exist
-        await RNFS.mkdir((0, core_1.getDirFromFilePath)(path));
-        const fromUrl = this.encodeUriIfRequired(url);
-        const { promise } = RNFS.downloadFile({
-            fromUrl,
-            toFile: path,
-        });
-        await promise;
-        if (options?.verifyHash) {
-            // RNFS returns hash as HEX
-            const fileHash = await RNFS.hash(path, options.verifyHash.algorithm);
-            const fileHashBuffer = core_1.Buffer.from(fileHash, 'hex');
-            // If hash doesn't match, remove file and throw error
-            if (fileHashBuffer.compare(options.verifyHash.hash) !== 0) {
-                await RNFS.unlink(path);
-                throw new core_1.CredoError(`Hash of downloaded file does not match expected hash. Expected: ${core_1.TypedArrayEncoder.toBase58(options.verifyHash.hash)}, Actual: ${core_1.TypedArrayEncoder.toBase58(fileHashBuffer)}`);
-            }
-        }
-    }
-    encodeUriIfRequired(uri) {
-        // Some characters in the URL might be invalid for
-        // the native os to handle. Only encode if necessary.
-        return uri === decodeURI(uri) ? encodeURI(uri) : uri;
-    }
-}
-exports.ReactNativeFileSystem = ReactNativeFileSystem;
-//# sourceMappingURL=ReactNativeFileSystem.js.map
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let __credo_ts_core = require("@credo-ts/core");
+__credo_ts_core = require_rolldown_runtime.__toESM(__credo_ts_core);
+let react_native = require("react-native");
+react_native = require_rolldown_runtime.__toESM(react_native);
+let react_native_fs = require("react-native-fs");
+react_native_fs = require_rolldown_runtime.__toESM(react_native_fs);
+
+//#region src/ReactNativeFileSystem.ts
+var ReactNativeFileSystem = class {
+	/**
+	* Create new ReactNativeFileSystem class instance.
+	*
+	* @param baseDataPath The base path to use for reading and writing data files used within the framework.
+	* Files will be created under baseDataPath/.afj directory. If not specified, it will be set to
+	* RNFS.DocumentDirectoryPath
+	* @param baseCachePath The base path to use for reading and writing cache files used within the framework.
+	* Files will be created under baseCachePath/.afj directory. If not specified, it will be set to
+	* RNFS.CachesDirectoryPath
+	* @param baseTempPath The base path to use for reading and writing temporary files within the framework.
+	* Files will be created under baseTempPath/.afj directory. If not specified, it will be set to
+	* RNFS.TemporaryDirectoryPath
+	*
+	* @see https://github.com/itinance/react-native-fs#constants
+	*/
+	constructor(options) {
+		this.dataPath = `${options?.baseDataPath ?? react_native_fs.DocumentDirectoryPath}/.afj`;
+		this.cachePath = options?.baseCachePath ? `${options?.baseCachePath}/.afj` : `${react_native_fs.CachesDirectoryPath}/.afj${react_native.Platform.OS === "android" ? "/cache" : ""}`;
+		this.tempPath = options?.baseTempPath ? `${options?.baseTempPath}/.afj` : `${react_native_fs.TemporaryDirectoryPath}/.afj${react_native.Platform.OS === "android" ? "/temp" : ""}`;
+	}
+	async exists(path) {
+		return react_native_fs.exists(path);
+	}
+	async createDirectory(path) {
+		await react_native_fs.mkdir((0, __credo_ts_core.getDirFromFilePath)(path));
+	}
+	async copyFile(sourcePath, destinationPath) {
+		await react_native_fs.copyFile(sourcePath, destinationPath);
+	}
+	async write(path, data) {
+		await react_native_fs.mkdir((0, __credo_ts_core.getDirFromFilePath)(path));
+		return react_native_fs.writeFile(path, data, "utf8");
+	}
+	async read(path) {
+		return react_native_fs.readFile(path, "utf8");
+	}
+	async delete(path) {
+		await react_native_fs.unlink(path);
+	}
+	async downloadToFile(url, path, options) {
+		await react_native_fs.mkdir((0, __credo_ts_core.getDirFromFilePath)(path));
+		const fromUrl = this.encodeUriIfRequired(url);
+		const { promise } = react_native_fs.downloadFile({
+			fromUrl,
+			toFile: path
+		});
+		await promise;
+		if (options?.verifyHash) {
+			const fileHash = await react_native_fs.hash(path, options.verifyHash.algorithm);
+			const fileHashBuffer = __credo_ts_core.Buffer.from(fileHash, "hex");
+			if (fileHashBuffer.compare(options.verifyHash.hash) !== 0) {
+				await react_native_fs.unlink(path);
+				throw new __credo_ts_core.CredoError(`Hash of downloaded file does not match expected hash. Expected: ${__credo_ts_core.TypedArrayEncoder.toBase58(options.verifyHash.hash)}, Actual: ${__credo_ts_core.TypedArrayEncoder.toBase58(fileHashBuffer)}`);
+			}
+		}
+	}
+	encodeUriIfRequired(uri) {
+		return uri === decodeURI(uri) ? encodeURI(uri) : uri;
+	}
+};
+
+//#endregion
+exports.ReactNativeFileSystem = ReactNativeFileSystem;

package/build/ReactNativeFileSystem.mjs

@@ -0,0 +1,70 @@
+import { Buffer, CredoError, TypedArrayEncoder, getDirFromFilePath } from "@credo-ts/core";
+import { Platform } from "react-native";
+import * as RNFS from "react-native-fs";
+
+//#region src/ReactNativeFileSystem.ts
+var ReactNativeFileSystem = class {
+	/**
+	* Create new ReactNativeFileSystem class instance.
+	*
+	* @param baseDataPath The base path to use for reading and writing data files used within the framework.
+	* Files will be created under baseDataPath/.afj directory. If not specified, it will be set to
+	* RNFS.DocumentDirectoryPath
+	* @param baseCachePath The base path to use for reading and writing cache files used within the framework.
+	* Files will be created under baseCachePath/.afj directory. If not specified, it will be set to
+	* RNFS.CachesDirectoryPath
+	* @param baseTempPath The base path to use for reading and writing temporary files within the framework.
+	* Files will be created under baseTempPath/.afj directory. If not specified, it will be set to
+	* RNFS.TemporaryDirectoryPath
+	*
+	* @see https://github.com/itinance/react-native-fs#constants
+	*/
+	constructor(options) {
+		this.dataPath = `${options?.baseDataPath ?? RNFS.DocumentDirectoryPath}/.afj`;
+		this.cachePath = options?.baseCachePath ? `${options?.baseCachePath}/.afj` : `${RNFS.CachesDirectoryPath}/.afj${Platform.OS === "android" ? "/cache" : ""}`;
+		this.tempPath = options?.baseTempPath ? `${options?.baseTempPath}/.afj` : `${RNFS.TemporaryDirectoryPath}/.afj${Platform.OS === "android" ? "/temp" : ""}`;
+	}
+	async exists(path) {
+		return RNFS.exists(path);
+	}
+	async createDirectory(path) {
+		await RNFS.mkdir(getDirFromFilePath(path));
+	}
+	async copyFile(sourcePath, destinationPath) {
+		await RNFS.copyFile(sourcePath, destinationPath);
+	}
+	async write(path, data) {
+		await RNFS.mkdir(getDirFromFilePath(path));
+		return RNFS.writeFile(path, data, "utf8");
+	}
+	async read(path) {
+		return RNFS.readFile(path, "utf8");
+	}
+	async delete(path) {
+		await RNFS.unlink(path);
+	}
+	async downloadToFile(url, path, options) {
+		await RNFS.mkdir(getDirFromFilePath(path));
+		const fromUrl = this.encodeUriIfRequired(url);
+		const { promise } = RNFS.downloadFile({
+			fromUrl,
+			toFile: path
+		});
+		await promise;
+		if (options?.verifyHash) {
+			const fileHash = await RNFS.hash(path, options.verifyHash.algorithm);
+			const fileHashBuffer = Buffer.from(fileHash, "hex");
+			if (fileHashBuffer.compare(options.verifyHash.hash) !== 0) {
+				await RNFS.unlink(path);
+				throw new CredoError(`Hash of downloaded file does not match expected hash. Expected: ${TypedArrayEncoder.toBase58(options.verifyHash.hash)}, Actual: ${TypedArrayEncoder.toBase58(fileHashBuffer)}`);
+			}
+		}
+	}
+	encodeUriIfRequired(uri) {
+		return uri === decodeURI(uri) ? encodeURI(uri) : uri;
+	}
+};
+
+//#endregion
+export { ReactNativeFileSystem };
+//# sourceMappingURL=ReactNativeFileSystem.mjs.map

package/build/ReactNativeFileSystem.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactNativeFileSystem.mjs","names":[],"sources":["../src/ReactNativeFileSystem.ts"],"sourcesContent":["import type { DownloadToFileOptions, FileSystem } from '@credo-ts/core'\n\nimport { Buffer, CredoError, TypedArrayEncoder, getDirFromFilePath } from '@credo-ts/core'\nimport { Platform } from 'react-native'\nimport * as RNFS from 'react-native-fs'\n\nexport class ReactNativeFileSystem implements FileSystem {\n  public readonly dataPath\n  public readonly cachePath\n  public readonly tempPath\n\n  /**\n   * Create new ReactNativeFileSystem class instance.\n   *\n   * @param baseDataPath The base path to use for reading and writing data files used within the framework.\n   * Files will be created under baseDataPath/.afj directory. If not specified, it will be set to\n   * RNFS.DocumentDirectoryPath\n   * @param baseCachePath The base path to use for reading and writing cache files used within the framework.\n   * Files will be created under baseCachePath/.afj directory. If not specified, it will be set to\n   * RNFS.CachesDirectoryPath\n   * @param baseTempPath The base path to use for reading and writing temporary files within the framework.\n   * Files will be created under baseTempPath/.afj directory. If not specified, it will be set to\n   * RNFS.TemporaryDirectoryPath\n   *\n   * @see https://github.com/itinance/react-native-fs#constants\n   */\n  public constructor(options?: { baseDataPath?: string; baseCachePath?: string; baseTempPath?: string }) {\n    this.dataPath = `${options?.baseDataPath ?? RNFS.DocumentDirectoryPath}/.afj`\n    // In Android, TemporaryDirectoryPath falls back to CachesDirectoryPath\n    this.cachePath = options?.baseCachePath\n      ? `${options?.baseCachePath}/.afj`\n      : `${RNFS.CachesDirectoryPath}/.afj${Platform.OS === 'android' ? '/cache' : ''}`\n    this.tempPath = options?.baseTempPath\n      ? `${options?.baseTempPath}/.afj`\n      : `${RNFS.TemporaryDirectoryPath}/.afj${Platform.OS === 'android' ? '/temp' : ''}`\n  }\n\n  public async exists(path: string): Promise<boolean> {\n    return RNFS.exists(path)\n  }\n\n  public async createDirectory(path: string): Promise<void> {\n    await RNFS.mkdir(getDirFromFilePath(path))\n  }\n\n  public async copyFile(sourcePath: string, destinationPath: string): Promise<void> {\n    await RNFS.copyFile(sourcePath, destinationPath)\n  }\n\n  public async write(path: string, data: string): Promise<void> {\n    // Make sure parent directories exist\n    await RNFS.mkdir(getDirFromFilePath(path))\n\n    return RNFS.writeFile(path, data, 'utf8')\n  }\n\n  public async read(path: string): Promise<string> {\n    return RNFS.readFile(path, 'utf8')\n  }\n\n  public async delete(path: string): Promise<void> {\n    await RNFS.unlink(path)\n  }\n\n  public async downloadToFile(url: string, path: string, options?: DownloadToFileOptions) {\n    // Make sure parent directories exist\n    await RNFS.mkdir(getDirFromFilePath(path))\n\n    const fromUrl = this.encodeUriIfRequired(url)\n\n    const { promise } = RNFS.downloadFile({\n      fromUrl,\n      toFile: path,\n    })\n\n    await promise\n\n    if (options?.verifyHash) {\n      // RNFS returns hash as HEX\n      const fileHash = await RNFS.hash(path, options.verifyHash.algorithm)\n      const fileHashBuffer = Buffer.from(fileHash, 'hex')\n\n      // If hash doesn't match, remove file and throw error\n      if (fileHashBuffer.compare(options.verifyHash.hash) !== 0) {\n        await RNFS.unlink(path)\n        throw new CredoError(\n          `Hash of downloaded file does not match expected hash. Expected: ${TypedArrayEncoder.toBase58(\n            options.verifyHash.hash\n          )}, Actual: ${TypedArrayEncoder.toBase58(fileHashBuffer)}`\n        )\n      }\n    }\n  }\n\n  private encodeUriIfRequired(uri: string) {\n    // Some characters in the URL might be invalid for\n    // the native os to handle. Only encode if necessary.\n    return uri === decodeURI(uri) ? encodeURI(uri) : uri\n  }\n}\n"],"mappings":";;;;;AAMA,IAAa,wBAAb,MAAyD;;;;;;;;;;;;;;;;CAoBvD,AAAO,YAAY,SAAoF;AACrG,OAAK,WAAW,GAAG,SAAS,gBAAgB,KAAK,sBAAsB;AAEvE,OAAK,YAAY,SAAS,gBACtB,GAAG,SAAS,cAAc,SAC1B,GAAG,KAAK,oBAAoB,OAAO,SAAS,OAAO,YAAY,WAAW;AAC9E,OAAK,WAAW,SAAS,eACrB,GAAG,SAAS,aAAa,SACzB,GAAG,KAAK,uBAAuB,OAAO,SAAS,OAAO,YAAY,UAAU;;CAGlF,MAAa,OAAO,MAAgC;AAClD,SAAO,KAAK,OAAO,KAAK;;CAG1B,MAAa,gBAAgB,MAA6B;AACxD,QAAM,KAAK,MAAM,mBAAmB,KAAK,CAAC;;CAG5C,MAAa,SAAS,YAAoB,iBAAwC;AAChF,QAAM,KAAK,SAAS,YAAY,gBAAgB;;CAGlD,MAAa,MAAM,MAAc,MAA6B;AAE5D,QAAM,KAAK,MAAM,mBAAmB,KAAK,CAAC;AAE1C,SAAO,KAAK,UAAU,MAAM,MAAM,OAAO;;CAG3C,MAAa,KAAK,MAA+B;AAC/C,SAAO,KAAK,SAAS,MAAM,OAAO;;CAGpC,MAAa,OAAO,MAA6B;AAC/C,QAAM,KAAK,OAAO,KAAK;;CAGzB,MAAa,eAAe,KAAa,MAAc,SAAiC;AAEtF,QAAM,KAAK,MAAM,mBAAmB,KAAK,CAAC;EAE1C,MAAM,UAAU,KAAK,oBAAoB,IAAI;EAE7C,MAAM,EAAE,YAAY,KAAK,aAAa;GACpC;GACA,QAAQ;GACT,CAAC;AAEF,QAAM;AAEN,MAAI,SAAS,YAAY;GAEvB,MAAM,WAAW,MAAM,KAAK,KAAK,MAAM,QAAQ,WAAW,UAAU;GACpE,MAAM,iBAAiB,OAAO,KAAK,UAAU,MAAM;AAGnD,OAAI,eAAe,QAAQ,QAAQ,WAAW,KAAK,KAAK,GAAG;AACzD,UAAM,KAAK,OAAO,KAAK;AACvB,UAAM,IAAI,WACR,mEAAmE,kBAAkB,SACnF,QAAQ,WAAW,KACpB,CAAC,YAAY,kBAAkB,SAAS,eAAe,GACzD;;;;CAKP,AAAQ,oBAAoB,KAAa;AAGvC,SAAO,QAAQ,UAAU,IAAI,GAAG,UAAU,IAAI,GAAG"}

package/build/_virtual/rolldown_runtime.js

@@ -0,0 +1,25 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/build/index.d.mts

@@ -0,0 +1,10 @@
+import { SecureEnvironmentKeyManagementService } from "./kms/SecureEnvironmentKeyManagementService.mjs";
+import "react-native-get-random-values";
+import "@azure/core-asynciterator-polyfill";
+import { AgentDependencies } from "@credo-ts/core";
+
+//#region src/index.d.ts
+declare const agentDependencies: AgentDependencies;
+//#endregion
+export { SecureEnvironmentKeyManagementService, agentDependencies };
+//# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;cAcM,mBAAmB"}

package/build/index.d.ts

@@ -1,6 +1,8 @@
-import 'react-native-get-random-values';
-import '@azure/core-asynciterator-polyfill';
-import type { AgentDependencies } from '@credo-ts/core';
-export { SecureEnvironmentKeyManagementService } from './kms/SecureEnvironmentKeyManagementService';
+import { SecureEnvironmentKeyManagementService } from "./kms/SecureEnvironmentKeyManagementService.js";
+import { AgentDependencies } from "@credo-ts/core";
+
+//#region src/index.d.ts
 declare const agentDependencies: AgentDependencies;
-export { agentDependencies };
+//#endregion
+export { SecureEnvironmentKeyManagementService, agentDependencies };
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;AASmG,cAK7F,iBAKL,EALwB,iBAAA"}

package/build/index.js

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.agentDependencies = exports.SecureEnvironmentKeyManagementService = void 0;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+const require_ReactNativeFileSystem = require('./ReactNativeFileSystem.js');
+const require_SecureEnvironmentKeyManagementService = require('./kms/SecureEnvironmentKeyManagementService.js');
 require("react-native-get-random-values");
 require("@azure/core-asynciterator-polyfill");
-const events_1 = require("events");
-const ReactNativeFileSystem_1 = require("./ReactNativeFileSystem");
-var SecureEnvironmentKeyManagementService_1 = require("./kms/SecureEnvironmentKeyManagementService");
-Object.defineProperty(exports, "SecureEnvironmentKeyManagementService", { enumerable: true, get: function () { return SecureEnvironmentKeyManagementService_1.SecureEnvironmentKeyManagementService; } });
-const fetch = global.fetch;
-const WebSocket = global.WebSocket;
+let events = require("events");
+events = require_rolldown_runtime.__toESM(events);
+
+//#region src/index.ts
 const agentDependencies = {
-    FileSystem: ReactNativeFileSystem_1.ReactNativeFileSystem,
-    fetch,
-    EventEmitterClass: events_1.EventEmitter,
-    WebSocketClass: WebSocket,
+	FileSystem: require_ReactNativeFileSystem.ReactNativeFileSystem,
+	fetch: global.fetch,
+	EventEmitterClass: events.EventEmitter,
+	WebSocketClass: global.WebSocket
 };
-exports.agentDependencies = agentDependencies;
-//# sourceMappingURL=index.js.map
+
+//#endregion
+exports.SecureEnvironmentKeyManagementService = require_SecureEnvironmentKeyManagementService.SecureEnvironmentKeyManagementService;
+exports.agentDependencies = agentDependencies;

package/build/index.mjs

@@ -0,0 +1,17 @@
+import { ReactNativeFileSystem } from "./ReactNativeFileSystem.mjs";
+import { SecureEnvironmentKeyManagementService } from "./kms/SecureEnvironmentKeyManagementService.mjs";
+import "react-native-get-random-values";
+import "@azure/core-asynciterator-polyfill";
+import { EventEmitter } from "events";
+
+//#region src/index.ts
+const agentDependencies = {
+	FileSystem: ReactNativeFileSystem,
+	fetch: global.fetch,
+	EventEmitterClass: EventEmitter,
+	WebSocketClass: global.WebSocket
+};
+
+//#endregion
+export { SecureEnvironmentKeyManagementService, agentDependencies };
+//# sourceMappingURL=index.mjs.map

package/build/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["agentDependencies: AgentDependencies"],"sources":["../src/index.ts"],"sourcesContent":["import 'react-native-get-random-values'\nimport '@azure/core-asynciterator-polyfill'\n\nimport type { AgentDependencies } from '@credo-ts/core'\n\nimport { EventEmitter } from 'events'\n\nimport { ReactNativeFileSystem } from './ReactNativeFileSystem'\n\nexport { SecureEnvironmentKeyManagementService } from './kms/SecureEnvironmentKeyManagementService'\n\nconst fetch = global.fetch as unknown as AgentDependencies['fetch']\nconst WebSocket = global.WebSocket as unknown as AgentDependencies['WebSocketClass']\n\nconst agentDependencies: AgentDependencies = {\n  FileSystem: ReactNativeFileSystem,\n  fetch,\n  EventEmitterClass: EventEmitter,\n  WebSocketClass: WebSocket,\n}\n\nexport { agentDependencies }\n"],"mappings":";;;;;;;AAcA,MAAMA,oBAAuC;CAC3C,YAAY;CACZ,OALY,OAAO;CAMnB,mBAAmB;CACnB,gBANgB,OAAO;CAOxB"}

package/build/kms/SecureEnvironmentKeyManagementService.d.mts

@@ -0,0 +1,22 @@
+import { AgentContext, Kms } from "@credo-ts/core";
+
+//#region src/kms/SecureEnvironmentKeyManagementService.d.ts
+declare class SecureEnvironmentKeyManagementService implements Kms.KeyManagementService {
+  readonly backend = "secureEnvironment";
+  private readonly secureEnvironment;
+  isOperationSupported(_agentContext: AgentContext, operation: Kms.KmsOperation): boolean;
+  randomBytes(_agentContext: AgentContext, _options: Kms.KmsRandomBytesOptions): Kms.KmsRandomBytesReturn;
+  getPublicKey(_agentContext: AgentContext, keyId: string): Promise<Kms.KmsJwkPublic | null>;
+  importKey(): Promise<Kms.KmsImportKeyReturn<Kms.KmsJwkPrivate>>;
+  deleteKey(_agentContext: AgentContext, options: Kms.KmsDeleteKeyOptions): Promise<boolean>;
+  encrypt(): Promise<Kms.KmsEncryptReturn>;
+  decrypt(): Promise<Kms.KmsDecryptReturn>;
+  createKey(_agentContext: AgentContext, options: Kms.KmsCreateKeyOptions): Promise<Kms.KmsCreateKeyReturn>;
+  sign(_agentContext: AgentContext, options: Kms.KmsSignOptions): Promise<Kms.KmsSignReturn>;
+  verify(): Promise<Kms.KmsVerifyReturn>;
+  private publicJwkFromPublicKeyBytes;
+  private getKeyAsserted;
+}
+//#endregion
+export { SecureEnvironmentKeyManagementService };
+//# sourceMappingURL=SecureEnvironmentKeyManagementService.d.mts.map

package/build/kms/SecureEnvironmentKeyManagementService.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecureEnvironmentKeyManagementService.d.mts","names":[],"sources":["../../src/kms/SecureEnvironmentKeyManagementService.ts"],"sourcesContent":[],"mappings":";;;cAMa,qCAAA,YAAiD,GAAA,CAAI;EAArD,SAAA,OAAA,GAAA,mBAAA;EAAsC,iBAAA,iBAAA;sBAIN,CAAA,aAAA,EAAA,YAAA,EAAA,SAAA,EAAyB,GAAA,CAAI,YAA7B,CAAA,EAAA,OAAA;aAA6B,CAAA,aAAA,EAgBtC,YAhBsC,EAAA,QAAA,EAgBd,GAAA,CAAI,qBAhBU,CAAA,EAgBc,GAAA,CAAI,oBAhBlB;cAgBtC,CAAA,aAAA,EAIO,YAJP,EAAA,KAAA,EAAA,MAAA,CAAA,EAIqC,OAJrC,CAI6C,GAAA,CAAI,YAJjD,GAAA,IAAA,CAAA;WAA4B,CAAA,CAAA,EAapC,OAboC,CAa5B,GAAA,CAAI,kBAbwB,CAaL,GAAA,CAAI,aAbC,CAAA,CAAA;WAA4B,CAAA,aAAA,EAiBpD,YAjBoD,EAAA,OAAA,EAiB7B,GAAA,CAAI,mBAjByB,CAAA,EAiBH,OAjBG,CAAA,OAAA,CAAA;SAIjD,CAAA,CAAA,EA6BjB,OA7BiB,CA6BT,GAAA,CAAI,gBA7BK,CAAA;SAA0C,CAAA,CAAA,EAiC3D,OAjC2D,CAiCnD,GAAA,CAAI,gBAjC+C,CAAA;WAAZ,CAAA,aAAA,EAsCtD,YAtCsD,EAAA,OAAA,EAuC5D,GAAA,CAAI,mBAvCwD,CAAA,EAwCpE,OAxCoE,CAwC5D,GAAA,CAAI,kBAxCwD,CAAA;MASd,CAAA,aAAI,EAiE5B,YAjE4B,EAAA,OAAA,EAiEL,GAAA,CAAI,cAjEC,CAAA,EAiEgB,OAjEhB,CAiEwB,GAAA,CAAI,aAjE5B,CAAA;QAA3B,CAAA,CAAI,EA8Ff,OA9Fe,CA8FP,GAAA,CAAI,eA9FG,CAAA;UAAZ,2BAAA;UAIY,cAAA"}

package/build/kms/SecureEnvironmentKeyManagementService.d.ts

@@ -1,18 +1,22 @@
-import type { AgentContext } from '@credo-ts/core';
-import { Kms } from '@credo-ts/core';
-export declare class SecureEnvironmentKeyManagementService implements Kms.KeyManagementService {
-    readonly backend = "secureEnvironment";
-    private readonly secureEnvironment;
-    isOperationSupported(_agentContext: AgentContext, operation: Kms.KmsOperation): boolean;
-    randomBytes(_agentContext: AgentContext, _options: Kms.KmsRandomBytesOptions): Kms.KmsRandomBytesReturn;
-    getPublicKey(_agentContext: AgentContext, keyId: string): Promise<Kms.KmsJwkPublic | null>;
-    importKey(): Promise<Kms.KmsImportKeyReturn<Kms.KmsJwkPrivate>>;
-    deleteKey(_agentContext: AgentContext, options: Kms.KmsDeleteKeyOptions): Promise<boolean>;
-    encrypt(): Promise<Kms.KmsEncryptReturn>;
-    decrypt(): Promise<Kms.KmsDecryptReturn>;
-    createKey(_agentContext: AgentContext, options: Kms.KmsCreateKeyOptions): Promise<Kms.KmsCreateKeyReturn>;
-    sign(_agentContext: AgentContext, options: Kms.KmsSignOptions): Promise<Kms.KmsSignReturn>;
-    verify(): Promise<Kms.KmsVerifyReturn>;
-    private publicJwkFromPublicKeyBytes;
-    private getKeyAsserted;
+import { AgentContext, Kms } from "@credo-ts/core";
+
+//#region src/kms/SecureEnvironmentKeyManagementService.d.ts
+declare class SecureEnvironmentKeyManagementService implements Kms.KeyManagementService {
+  readonly backend = "secureEnvironment";
+  private readonly secureEnvironment;
+  isOperationSupported(_agentContext: AgentContext, operation: Kms.KmsOperation): boolean;
+  randomBytes(_agentContext: AgentContext, _options: Kms.KmsRandomBytesOptions): Kms.KmsRandomBytesReturn;
+  getPublicKey(_agentContext: AgentContext, keyId: string): Promise<Kms.KmsJwkPublic | null>;
+  importKey(): Promise<Kms.KmsImportKeyReturn<Kms.KmsJwkPrivate>>;
+  deleteKey(_agentContext: AgentContext, options: Kms.KmsDeleteKeyOptions): Promise<boolean>;
+  encrypt(): Promise<Kms.KmsEncryptReturn>;
+  decrypt(): Promise<Kms.KmsDecryptReturn>;
+  createKey(_agentContext: AgentContext, options: Kms.KmsCreateKeyOptions): Promise<Kms.KmsCreateKeyReturn>;
+  sign(_agentContext: AgentContext, options: Kms.KmsSignOptions): Promise<Kms.KmsSignReturn>;
+  verify(): Promise<Kms.KmsVerifyReturn>;
+  private publicJwkFromPublicKeyBytes;
+  private getKeyAsserted;
 }
+//#endregion
+export { SecureEnvironmentKeyManagementService };
+//# sourceMappingURL=SecureEnvironmentKeyManagementService.d.ts.map

package/build/kms/SecureEnvironmentKeyManagementService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecureEnvironmentKeyManagementService.d.ts","names":[],"sources":["../../src/kms/SecureEnvironmentKeyManagementService.ts"],"sourcesContent":[],"mappings":";;;cAMa,qCAAA,YAAiD,GAAA,CAAI;EAArD,SAAA,OAAA,GAAA,mBAAA;EAAsC,iBAAA,iBAAA;sBAIN,CAAA,aAAA,EAAA,YAAA,EAAA,SAAA,EAAyB,GAAA,CAAI,YAA7B,CAAA,EAAA,OAAA;aAA6B,CAAA,aAAA,EAgBtC,YAhBsC,EAAA,QAAA,EAgBd,GAAA,CAAI,qBAhBU,CAAA,EAgBc,GAAA,CAAI,oBAhBlB;cAgBtC,CAAA,aAAA,EAIO,YAJP,EAAA,KAAA,EAAA,MAAA,CAAA,EAIqC,OAJrC,CAI6C,GAAA,CAAI,YAJjD,GAAA,IAAA,CAAA;WAA4B,CAAA,CAAA,EAapC,OAboC,CAa5B,GAAA,CAAI,kBAbwB,CAaL,GAAA,CAAI,aAbC,CAAA,CAAA;WAA4B,CAAA,aAAA,EAiBpD,YAjBoD,EAAA,OAAA,EAiB7B,GAAA,CAAI,mBAjByB,CAAA,EAiBH,OAjBG,CAAA,OAAA,CAAA;SAIjD,CAAA,CAAA,EA6BjB,OA7BiB,CA6BT,GAAA,CAAI,gBA7BK,CAAA;SAA0C,CAAA,CAAA,EAiC3D,OAjC2D,CAiCnD,GAAA,CAAI,gBAjC+C,CAAA;WAAZ,CAAA,aAAA,EAsCtD,YAtCsD,EAAA,OAAA,EAuC5D,GAAA,CAAI,mBAvCwD,CAAA,EAwCpE,OAxCoE,CAwC5D,GAAA,CAAI,kBAxCwD,CAAA;MASd,CAAA,aAAI,EAiE5B,YAjE4B,EAAA,OAAA,EAiEL,GAAA,CAAI,cAjEC,CAAA,EAiEgB,OAjEhB,CAiEwB,GAAA,CAAI,aAjE5B,CAAA;QAA3B,CAAA,CAAI,EA8Ff,OA9Fe,CA8FP,GAAA,CAAI,eA9FG,CAAA;UAAZ,2BAAA;UAIY,cAAA"}

package/build/kms/SecureEnvironmentKeyManagementService.js

@@ -1,133 +1,101 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SecureEnvironmentKeyManagementService = void 0;
-const core_1 = require("@credo-ts/core");
-const secureEnvironment_1 = require("./secureEnvironment");
-class SecureEnvironmentKeyManagementService {
-    constructor() {
-        this.backend = 'secureEnvironment';
-        this.secureEnvironment = (0, secureEnvironment_1.importSecureEnvironment)();
-    }
-    isOperationSupported(_agentContext, operation) {
-        if (operation.operation === 'createKey') {
-            return operation.type.kty === 'EC' && operation.type.crv === 'P-256';
-        }
-        if (operation.operation === 'sign') {
-            return operation.algorithm === 'ES256';
-        }
-        if (operation.operation === 'deleteKey') {
-            return true;
-        }
-        return false;
-    }
-    randomBytes(_agentContext, _options) {
-        throw new core_1.Kms.KeyManagementError(`Generating random bytes is not supported for backend '${this.backend}'`);
-    }
-    async getPublicKey(_agentContext, keyId) {
-        try {
-            return await this.getKeyAsserted(keyId);
-        }
-        catch (error) {
-            if (error instanceof core_1.Kms.KeyManagementKeyNotFoundError)
-                return null;
-            throw error;
-        }
-    }
-    async importKey() {
-        throw new core_1.Kms.KeyManagementError(`Importing a key is not supported for backend '${this.backend}'`);
-    }
-    async deleteKey(_agentContext, options) {
-        try {
-            await this.secureEnvironment.deleteKey(options.keyId);
-            return true;
-        }
-        catch (error) {
-            if (error instanceof this.secureEnvironment.KeyNotFoundError) {
-                return false;
-            }
-            throw new core_1.Kms.KeyManagementError(`Error deleting key with id '${options.keyId}' in backend '${this.backend}'`, {
-                cause: error,
-            });
-        }
-    }
-    async encrypt() {
-        throw new core_1.Kms.KeyManagementError(`Encryption is not supported for backend '${this.backend}'`);
-    }
-    async decrypt() {
-        throw new core_1.Kms.KeyManagementError(`Decryption is not supported for backend '${this.backend}'`);
-    }
-    async createKey(_agentContext, options) {
-        if (options.type.kty !== 'EC') {
-            throw new core_1.Kms.KeyManagementAlgorithmNotSupportedError(`kty ${options.type.kty}. Only EC P-256 supported.`, this.backend);
-        }
-        if (options.type.crv !== 'P-256') {
-            throw new core_1.Kms.KeyManagementAlgorithmNotSupportedError(`kty ${options.type.kty} with crv ${options.type.crv}. Only EC P-256 supported.`, this.backend);
-        }
-        const keyId = options.keyId ?? core_1.utils.uuid();
-        try {
-            await this.secureEnvironment.generateKeypair(keyId);
-            return {
-                keyId,
-                publicJwk: await this.getKeyAsserted(keyId),
-            };
-        }
-        catch (error) {
-            if (error instanceof core_1.Kms.KeyManagementError)
-                throw error;
-            if (error instanceof this.secureEnvironment.KeyAlreadyExistsError) {
-                throw new core_1.Kms.KeyManagementKeyExistsError(keyId, this.backend);
-            }
-            throw new core_1.Kms.KeyManagementError('Error creating key', { cause: error });
-        }
-    }
-    async sign(_agentContext, options) {
-        if (options.algorithm !== 'ES256') {
-            throw new core_1.Kms.KeyManagementAlgorithmNotSupportedError(`algorithm '${options.algorithm}'. Only 'ES256' supported.`, this.backend);
-        }
-        try {
-            // TODO: can we store something like 'use' for the key in secure environment?
-            // Kms.assertKeyAllowsSign(publicJwk)
-            // Perform the signing operation
-            const signature = await this.secureEnvironment.sign(options.keyId, options.data);
-            return {
-                signature,
-            };
-        }
-        catch (error) {
-            if (error instanceof this.secureEnvironment.KeyNotFoundError) {
-                throw new core_1.Kms.KeyManagementKeyNotFoundError(options.keyId, this.backend);
-            }
-            throw new core_1.Kms.KeyManagementError('Error signing with key', { cause: error });
-        }
-    }
-    async verify() {
-        throw new core_1.Kms.KeyManagementError(`verification of signatures is not supported for backend '${this.backend}'`);
-    }
-    publicJwkFromPublicKeyBytes(key, keyId) {
-        const publicJwk = core_1.Kms.PublicJwk.fromPublicKey({
-            kty: 'EC',
-            crv: 'P-256',
-            publicKey: key,
-        }).toJson();
-        return {
-            ...publicJwk,
-            kid: keyId,
-        };
-    }
-    async getKeyAsserted(keyId) {
-        try {
-            const publicKeyBytes = await this.secureEnvironment.getPublicBytesForKeyId(keyId);
-            return this.publicJwkFromPublicKeyBytes(publicKeyBytes, keyId);
-        }
-        catch (error) {
-            if (error instanceof this.secureEnvironment.KeyNotFoundError) {
-                throw new core_1.Kms.KeyManagementKeyNotFoundError(keyId, this.backend);
-            }
-            throw new core_1.Kms.KeyManagementError(`Error retrieving key with id '${keyId}' from backend ${this.backend}`, {
-                cause: error,
-            });
-        }
-    }
-}
-exports.SecureEnvironmentKeyManagementService = SecureEnvironmentKeyManagementService;
-//# sourceMappingURL=SecureEnvironmentKeyManagementService.js.map
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_secureEnvironment = require('./secureEnvironment.js');
+let __credo_ts_core = require("@credo-ts/core");
+__credo_ts_core = require_rolldown_runtime.__toESM(__credo_ts_core);
+
+//#region src/kms/SecureEnvironmentKeyManagementService.ts
+var SecureEnvironmentKeyManagementService = class {
+	constructor() {
+		this.backend = "secureEnvironment";
+		this.secureEnvironment = require_secureEnvironment.importSecureEnvironment();
+	}
+	isOperationSupported(_agentContext, operation) {
+		if (operation.operation === "createKey") return operation.type.kty === "EC" && operation.type.crv === "P-256";
+		if (operation.operation === "sign") return operation.algorithm === "ES256";
+		if (operation.operation === "deleteKey") return true;
+		return false;
+	}
+	randomBytes(_agentContext, _options) {
+		throw new __credo_ts_core.Kms.KeyManagementError(`Generating random bytes is not supported for backend '${this.backend}'`);
+	}
+	async getPublicKey(_agentContext, keyId) {
+		try {
+			return await this.getKeyAsserted(keyId);
+		} catch (error) {
+			if (error instanceof __credo_ts_core.Kms.KeyManagementKeyNotFoundError) return null;
+			throw error;
+		}
+	}
+	async importKey() {
+		throw new __credo_ts_core.Kms.KeyManagementError(`Importing a key is not supported for backend '${this.backend}'`);
+	}
+	async deleteKey(_agentContext, options) {
+		const secureEnvironment = await this.secureEnvironment;
+		try {
+			await secureEnvironment.deleteKey(options.keyId);
+			return true;
+		} catch (error) {
+			if (error instanceof secureEnvironment.KeyNotFoundError) return false;
+			throw new __credo_ts_core.Kms.KeyManagementError(`Error deleting key with id '${options.keyId}' in backend '${this.backend}'`, { cause: error });
+		}
+	}
+	async encrypt() {
+		throw new __credo_ts_core.Kms.KeyManagementError(`Encryption is not supported for backend '${this.backend}'`);
+	}
+	async decrypt() {
+		throw new __credo_ts_core.Kms.KeyManagementError(`Decryption is not supported for backend '${this.backend}'`);
+	}
+	async createKey(_agentContext, options) {
+		if (options.type.kty !== "EC") throw new __credo_ts_core.Kms.KeyManagementAlgorithmNotSupportedError(`kty ${options.type.kty}. Only EC P-256 supported.`, this.backend);
+		if (options.type.crv !== "P-256") throw new __credo_ts_core.Kms.KeyManagementAlgorithmNotSupportedError(`kty ${options.type.kty} with crv ${options.type.crv}. Only EC P-256 supported.`, this.backend);
+		const keyId = options.keyId ?? __credo_ts_core.utils.uuid();
+		const secureEnvironment = await this.secureEnvironment;
+		try {
+			await secureEnvironment.generateKeypair(keyId);
+			return {
+				keyId,
+				publicJwk: await this.getKeyAsserted(keyId)
+			};
+		} catch (error) {
+			if (error instanceof __credo_ts_core.Kms.KeyManagementError) throw error;
+			if (error instanceof secureEnvironment.KeyAlreadyExistsError) throw new __credo_ts_core.Kms.KeyManagementKeyExistsError(keyId, this.backend);
+			throw new __credo_ts_core.Kms.KeyManagementError("Error creating key", { cause: error });
+		}
+	}
+	async sign(_agentContext, options) {
+		if (options.algorithm !== "ES256") throw new __credo_ts_core.Kms.KeyManagementAlgorithmNotSupportedError(`algorithm '${options.algorithm}'. Only 'ES256' supported.`, this.backend);
+		const secureEnvironment = await this.secureEnvironment;
+		try {
+			return { signature: await secureEnvironment.sign(options.keyId, options.data) };
+		} catch (error) {
+			if (error instanceof secureEnvironment.KeyNotFoundError) throw new __credo_ts_core.Kms.KeyManagementKeyNotFoundError(options.keyId, this.backend);
+			throw new __credo_ts_core.Kms.KeyManagementError("Error signing with key", { cause: error });
+		}
+	}
+	async verify() {
+		throw new __credo_ts_core.Kms.KeyManagementError(`verification of signatures is not supported for backend '${this.backend}'`);
+	}
+	publicJwkFromPublicKeyBytes(key, keyId) {
+		return {
+			...__credo_ts_core.Kms.PublicJwk.fromPublicKey({
+				kty: "EC",
+				crv: "P-256",
+				publicKey: key
+			}).toJson(),
+			kid: keyId
+		};
+	}
+	async getKeyAsserted(keyId) {
+		const secureEnvironment = await this.secureEnvironment;
+		try {
+			const publicKeyBytes = await secureEnvironment.getPublicBytesForKeyId(keyId);
+			return this.publicJwkFromPublicKeyBytes(publicKeyBytes, keyId);
+		} catch (error) {
+			if (error instanceof secureEnvironment.KeyNotFoundError) throw new __credo_ts_core.Kms.KeyManagementKeyNotFoundError(keyId, this.backend);
+			throw new __credo_ts_core.Kms.KeyManagementError(`Error retrieving key with id '${keyId}' from backend ${this.backend}`, { cause: error });
+		}
+	}
+};
+
+//#endregion
+exports.SecureEnvironmentKeyManagementService = SecureEnvironmentKeyManagementService;

package/build/kms/SecureEnvironmentKeyManagementService.mjs

@@ -0,0 +1,100 @@
+import { importSecureEnvironment } from "./secureEnvironment.mjs";
+import { Kms, utils } from "@credo-ts/core";
+
+//#region src/kms/SecureEnvironmentKeyManagementService.ts
+var SecureEnvironmentKeyManagementService = class {
+	constructor() {
+		this.backend = "secureEnvironment";
+		this.secureEnvironment = importSecureEnvironment();
+	}
+	isOperationSupported(_agentContext, operation) {
+		if (operation.operation === "createKey") return operation.type.kty === "EC" && operation.type.crv === "P-256";
+		if (operation.operation === "sign") return operation.algorithm === "ES256";
+		if (operation.operation === "deleteKey") return true;
+		return false;
+	}
+	randomBytes(_agentContext, _options) {
+		throw new Kms.KeyManagementError(`Generating random bytes is not supported for backend '${this.backend}'`);
+	}
+	async getPublicKey(_agentContext, keyId) {
+		try {
+			return await this.getKeyAsserted(keyId);
+		} catch (error) {
+			if (error instanceof Kms.KeyManagementKeyNotFoundError) return null;
+			throw error;
+		}
+	}
+	async importKey() {
+		throw new Kms.KeyManagementError(`Importing a key is not supported for backend '${this.backend}'`);
+	}
+	async deleteKey(_agentContext, options) {
+		const secureEnvironment = await this.secureEnvironment;
+		try {
+			await secureEnvironment.deleteKey(options.keyId);
+			return true;
+		} catch (error) {
+			if (error instanceof secureEnvironment.KeyNotFoundError) return false;
+			throw new Kms.KeyManagementError(`Error deleting key with id '${options.keyId}' in backend '${this.backend}'`, { cause: error });
+		}
+	}
+	async encrypt() {
+		throw new Kms.KeyManagementError(`Encryption is not supported for backend '${this.backend}'`);
+	}
+	async decrypt() {
+		throw new Kms.KeyManagementError(`Decryption is not supported for backend '${this.backend}'`);
+	}
+	async createKey(_agentContext, options) {
+		if (options.type.kty !== "EC") throw new Kms.KeyManagementAlgorithmNotSupportedError(`kty ${options.type.kty}. Only EC P-256 supported.`, this.backend);
+		if (options.type.crv !== "P-256") throw new Kms.KeyManagementAlgorithmNotSupportedError(`kty ${options.type.kty} with crv ${options.type.crv}. Only EC P-256 supported.`, this.backend);
+		const keyId = options.keyId ?? utils.uuid();
+		const secureEnvironment = await this.secureEnvironment;
+		try {
+			await secureEnvironment.generateKeypair(keyId);
+			return {
+				keyId,
+				publicJwk: await this.getKeyAsserted(keyId)
+			};
+		} catch (error) {
+			if (error instanceof Kms.KeyManagementError) throw error;
+			if (error instanceof secureEnvironment.KeyAlreadyExistsError) throw new Kms.KeyManagementKeyExistsError(keyId, this.backend);
+			throw new Kms.KeyManagementError("Error creating key", { cause: error });
+		}
+	}
+	async sign(_agentContext, options) {
+		if (options.algorithm !== "ES256") throw new Kms.KeyManagementAlgorithmNotSupportedError(`algorithm '${options.algorithm}'. Only 'ES256' supported.`, this.backend);
+		const secureEnvironment = await this.secureEnvironment;
+		try {
+			return { signature: await secureEnvironment.sign(options.keyId, options.data) };
+		} catch (error) {
+			if (error instanceof secureEnvironment.KeyNotFoundError) throw new Kms.KeyManagementKeyNotFoundError(options.keyId, this.backend);
+			throw new Kms.KeyManagementError("Error signing with key", { cause: error });
+		}
+	}
+	async verify() {
+		throw new Kms.KeyManagementError(`verification of signatures is not supported for backend '${this.backend}'`);
+	}
+	publicJwkFromPublicKeyBytes(key, keyId) {
+		return {
+			...Kms.PublicJwk.fromPublicKey({
+				kty: "EC",
+				crv: "P-256",
+				publicKey: key
+			}).toJson(),
+			kid: keyId
+		};
+	}
+	async getKeyAsserted(keyId) {
+		const secureEnvironment = await this.secureEnvironment;
+		try {
+			const publicKeyBytes = await secureEnvironment.getPublicBytesForKeyId(keyId);
+			return this.publicJwkFromPublicKeyBytes(publicKeyBytes, keyId);
+		} catch (error) {
+			if (error instanceof secureEnvironment.KeyNotFoundError) throw new Kms.KeyManagementKeyNotFoundError(keyId, this.backend);
+			throw new Kms.KeyManagementError(`Error retrieving key with id '${keyId}' from backend ${this.backend}`, { cause: error });
+		}
+	}
+};
+
+//#endregion
+export { SecureEnvironmentKeyManagementService };
+//# sourceMappingURL=SecureEnvironmentKeyManagementService.mjs.map

package/build/kms/SecureEnvironmentKeyManagementService.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecureEnvironmentKeyManagementService.mjs","names":[],"sources":["../../src/kms/SecureEnvironmentKeyManagementService.ts"],"sourcesContent":["import type { AgentContext } from '@credo-ts/core'\n\nimport { Kms, utils } from '@credo-ts/core'\n\nimport { importSecureEnvironment } from './secureEnvironment'\n\nexport class SecureEnvironmentKeyManagementService implements Kms.KeyManagementService {\n  public readonly backend = 'secureEnvironment'\n  private readonly secureEnvironment = importSecureEnvironment()\n\n  public isOperationSupported(_agentContext: AgentContext, operation: Kms.KmsOperation): boolean {\n    if (operation.operation === 'createKey') {\n      return operation.type.kty === 'EC' && operation.type.crv === 'P-256'\n    }\n\n    if (operation.operation === 'sign') {\n      return operation.algorithm === 'ES256'\n    }\n\n    if (operation.operation === 'deleteKey') {\n      return true\n    }\n\n    return false\n  }\n\n  public randomBytes(_agentContext: AgentContext, _options: Kms.KmsRandomBytesOptions): Kms.KmsRandomBytesReturn {\n    throw new Kms.KeyManagementError(`Generating random bytes is not supported for backend '${this.backend}'`)\n  }\n\n  public async getPublicKey(_agentContext: AgentContext, keyId: string): Promise<Kms.KmsJwkPublic | null> {\n    try {\n      return await this.getKeyAsserted(keyId)\n    } catch (error) {\n      if (error instanceof Kms.KeyManagementKeyNotFoundError) return null\n      throw error\n    }\n  }\n\n  public async importKey(): Promise<Kms.KmsImportKeyReturn<Kms.KmsJwkPrivate>> {\n    throw new Kms.KeyManagementError(`Importing a key is not supported for backend '${this.backend}'`)\n  }\n\n  public async deleteKey(_agentContext: AgentContext, options: Kms.KmsDeleteKeyOptions): Promise<boolean> {\n    const secureEnvironment = await this.secureEnvironment\n    try {\n      await secureEnvironment.deleteKey(options.keyId)\n      return true\n    } catch (error) {\n      if (error instanceof secureEnvironment.KeyNotFoundError) {\n        return false\n      }\n\n      throw new Kms.KeyManagementError(`Error deleting key with id '${options.keyId}' in backend '${this.backend}'`, {\n        cause: error,\n      })\n    }\n  }\n\n  public async encrypt(): Promise<Kms.KmsEncryptReturn> {\n    throw new Kms.KeyManagementError(`Encryption is not supported for backend '${this.backend}'`)\n  }\n\n  public async decrypt(): Promise<Kms.KmsDecryptReturn> {\n    throw new Kms.KeyManagementError(`Decryption is not supported for backend '${this.backend}'`)\n  }\n\n  public async createKey(\n    _agentContext: AgentContext,\n    options: Kms.KmsCreateKeyOptions\n  ): Promise<Kms.KmsCreateKeyReturn> {\n    if (options.type.kty !== 'EC') {\n      throw new Kms.KeyManagementAlgorithmNotSupportedError(\n        `kty ${options.type.kty}. Only EC P-256 supported.`,\n        this.backend\n      )\n    }\n    if (options.type.crv !== 'P-256') {\n      throw new Kms.KeyManagementAlgorithmNotSupportedError(\n        `kty ${options.type.kty} with crv ${options.type.crv}. Only EC P-256 supported.`,\n        this.backend\n      )\n    }\n\n    const keyId = options.keyId ?? utils.uuid()\n    const secureEnvironment = await this.secureEnvironment\n\n    try {\n      await secureEnvironment.generateKeypair(keyId)\n\n      return {\n        keyId,\n        publicJwk: await this.getKeyAsserted(keyId),\n      }\n    } catch (error) {\n      if (error instanceof Kms.KeyManagementError) throw error\n      if (error instanceof secureEnvironment.KeyAlreadyExistsError) {\n        throw new Kms.KeyManagementKeyExistsError(keyId, this.backend)\n      }\n\n      throw new Kms.KeyManagementError('Error creating key', { cause: error })\n    }\n  }\n\n  public async sign(_agentContext: AgentContext, options: Kms.KmsSignOptions): Promise<Kms.KmsSignReturn> {\n    if (options.algorithm !== 'ES256') {\n      throw new Kms.KeyManagementAlgorithmNotSupportedError(\n        `algorithm '${options.algorithm}'. Only 'ES256' supported.`,\n        this.backend\n      )\n    }\n\n    const secureEnvironment = await this.secureEnvironment\n\n    try {\n      // TODO: can we store something like 'use' for the key in secure environment?\n      // Kms.assertKeyAllowsSign(publicJwk)\n\n      // Perform the signing operation\n      const signature = await secureEnvironment.sign(options.keyId, options.data)\n\n      return {\n        signature,\n      }\n    } catch (error) {\n      if (error instanceof secureEnvironment.KeyNotFoundError) {\n        throw new Kms.KeyManagementKeyNotFoundError(options.keyId, this.backend)\n      }\n\n      throw new Kms.KeyManagementError('Error signing with key', { cause: error })\n    }\n  }\n\n  public async verify(): Promise<Kms.KmsVerifyReturn> {\n    throw new Kms.KeyManagementError(`verification of signatures is not supported for backend '${this.backend}'`)\n  }\n\n  private publicJwkFromPublicKeyBytes(key: Uint8Array, keyId: string) {\n    const publicJwk = Kms.PublicJwk.fromPublicKey<Kms.P256PublicJwk['publicKey']>({\n      kty: 'EC',\n      crv: 'P-256',\n      publicKey: key,\n    }).toJson()\n\n    return {\n      ...publicJwk,\n      kid: keyId,\n    } satisfies Kms.KmsJwkPublicEc\n  }\n\n  private async getKeyAsserted(keyId: string) {\n    const secureEnvironment = await this.secureEnvironment\n\n    try {\n      const publicKeyBytes = await secureEnvironment.getPublicBytesForKeyId(keyId)\n      return this.publicJwkFromPublicKeyBytes(publicKeyBytes, keyId)\n    } catch (error) {\n      if (error instanceof secureEnvironment.KeyNotFoundError) {\n        throw new Kms.KeyManagementKeyNotFoundError(keyId, this.backend)\n      }\n\n      throw new Kms.KeyManagementError(`Error retrieving key with id '${keyId}' from backend ${this.backend}`, {\n        cause: error,\n      })\n    }\n  }\n}\n"],"mappings":"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"}

package/build/kms/secureEnvironment.js

@@ -1,13 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.importSecureEnvironment = importSecureEnvironment;
-function importSecureEnvironment() {
-    try {
-        const secureEnvironment = require('@animo-id/expo-secure-environment');
-        return secureEnvironment;
-    }
-    catch (_error) {
-        throw new Error('@animo-id/expo-secure-environment must be installed as a peer dependency');
-    }
+
+//#region src/kms/secureEnvironment.ts
+async function importSecureEnvironment() {
+	try {
+		return require("@animo-id/expo-secure-environment");
+	} catch (_error) {
+		throw new Error("@animo-id/expo-secure-environment must be installed as a peer dependency");
+	}
 }
-//# sourceMappingURL=secureEnvironment.js.map
+
+//#endregion
+exports.importSecureEnvironment = importSecureEnvironment;

package/build/kms/secureEnvironment.mjs

@@ -0,0 +1,12 @@
+//#region src/kms/secureEnvironment.ts
+async function importSecureEnvironment() {
+	try {
+		return await import("@animo-id/expo-secure-environment");
+	} catch (_error) {
+		throw new Error("@animo-id/expo-secure-environment must be installed as a peer dependency");
+	}
+}
+
+//#endregion
+export { importSecureEnvironment };
+//# sourceMappingURL=secureEnvironment.mjs.map

package/build/kms/secureEnvironment.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"secureEnvironment.mjs","names":[],"sources":["../../src/kms/secureEnvironment.ts"],"sourcesContent":["export async function importSecureEnvironment() {\n  try {\n    const secureEnvironment = await import('@animo-id/expo-secure-environment')\n    return secureEnvironment\n  } catch (_error) {\n    throw new Error('@animo-id/expo-secure-environment must be installed as a peer dependency')\n  }\n}\n"],"mappings":";AAAA,eAAsB,0BAA0B;AAC9C,KAAI;AAEF,SAD0B,MAAM,OAAO;UAEhC,QAAQ;AACf,QAAM,IAAI,MAAM,2EAA2E"}

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "@credo-ts/react-native",
-  "main": "build/index",
-  "types": "build/index",
-  "version": "0.6.0-alpha-20251010154241",
+  "exports": {
+    ".": {
+      "import": "./build/index.mjs",
+      "require": "./build/index.js",
+      "types": "./build/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "version": "0.6.0-alpha-20251010164336",
   "files": [
     "build"
   ],
@@ -19,13 +25,12 @@
   "dependencies": {
     "@azure/core-asynciterator-polyfill": "^1.0.2",
     "events": "^3.3.0",
-    "@credo-ts/core": "0.6.0-alpha-20251010154241"
+    "@credo-ts/core": "0.6.0-alpha-20251010164336"
   },
   "devDependencies": {
     "react-native": "^0.79.3",
     "react-native-fs": "^2.20.0",
     "react-native-get-random-values": "^1.8.0",
-    "rimraf": "^6.0.1",
     "typescript": "~5.8.3"
   },
   "peerDependencies": {
@@ -40,9 +45,9 @@
     }
   },
   "scripts": {
-    "build": "pnpm run clean && pnpm run compile",
-    "clean": "rimraf ./build",
-    "compile": "tsc -p tsconfig.build.json",
-    "test": "jest"
-  }
+    "build": "tsdown --config-loader unconfig"
+  },
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "module": "./build/index.mjs"
 }

package/build/ReactNativeFileSystem.d.ts

@@ -1,34 +0,0 @@
-import type { DownloadToFileOptions, FileSystem } from '@credo-ts/core';
-export declare class ReactNativeFileSystem implements FileSystem {
-    readonly dataPath: string;
-    readonly cachePath: string;
-    readonly tempPath: string;
-    /**
-     * Create new ReactNativeFileSystem class instance.
-     *
-     * @param baseDataPath The base path to use for reading and writing data files used within the framework.
-     * Files will be created under baseDataPath/.afj directory. If not specified, it will be set to
-     * RNFS.DocumentDirectoryPath
-     * @param baseCachePath The base path to use for reading and writing cache files used within the framework.
-     * Files will be created under baseCachePath/.afj directory. If not specified, it will be set to
-     * RNFS.CachesDirectoryPath
-     * @param baseTempPath The base path to use for reading and writing temporary files within the framework.
-     * Files will be created under baseTempPath/.afj directory. If not specified, it will be set to
-     * RNFS.TemporaryDirectoryPath
-     *
-     * @see https://github.com/itinance/react-native-fs#constants
-     */
-    constructor(options?: {
-        baseDataPath?: string;
-        baseCachePath?: string;
-        baseTempPath?: string;
-    });
-    exists(path: string): Promise<boolean>;
-    createDirectory(path: string): Promise<void>;
-    copyFile(sourcePath: string, destinationPath: string): Promise<void>;
-    write(path: string, data: string): Promise<void>;
-    read(path: string): Promise<string>;
-    delete(path: string): Promise<void>;
-    downloadToFile(url: string, path: string, options?: DownloadToFileOptions): Promise<void>;
-    private encodeUriIfRequired;
-}

package/build/ReactNativeFileSystem.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ReactNativeFileSystem.js","sourceRoot":"","sources":["../src/ReactNativeFileSystem.ts"],"names":[],"mappings":"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"}

package/build/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,0CAAuC;AACvC,8CAA2C;AAI3C,mCAAqC;AAErC,mEAA+D;AAE/D,qGAAmG;AAA1F,8JAAA,qCAAqC,OAAA;AAE9C,MAAM,KAAK,GAAG,MAAM,CAAC,KAA8C,CAAA;AACnE,MAAM,SAAS,GAAG,MAAM,CAAC,SAA2D,CAAA;AAEpF,MAAM,iBAAiB,GAAsB;IAC3C,UAAU,EAAE,6CAAqB;IACjC,KAAK;IACL,iBAAiB,EAAE,qBAAY;IAC/B,cAAc,EAAE,SAAS;CAC1B,CAAA;AAEQ,8CAAiB"}

package/build/kms/SecureEnvironmentKeyManagementService.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SecureEnvironmentKeyManagementService.js","sourceRoot":"","sources":["../../src/kms/SecureEnvironmentKeyManagementService.ts"],"names":[],"mappings":"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"}

package/build/kms/secureEnvironment.d.ts

@@ -1,8 +0,0 @@
-export declare function importSecureEnvironment(): {
-    sign: (id: string, message: Uint8Array) => Promise<Uint8Array>;
-    getPublicBytesForKeyId: (id: string) => Promise<Uint8Array>;
-    generateKeypair: (id: string) => Promise<void>;
-    deleteKey: (id: string) => Promise<void>;
-    KeyAlreadyExistsError: typeof Error;
-    KeyNotFoundError: typeof Error;
-};

package/build/kms/secureEnvironment.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"secureEnvironment.js","sourceRoot":"","sources":["../../src/kms/secureEnvironment.ts"],"names":[],"mappings":";;AAAA,0DAcC;AAdD,SAAgB,uBAAuB;IAQrC,IAAI,CAAC;QACH,MAAM,iBAAiB,GAAG,OAAO,CAAC,mCAAmC,CAAC,CAAA;QACtE,OAAO,iBAAiB,CAAA;IAC1B,CAAC;IAAC,OAAO,MAAM,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,0EAA0E,CAAC,CAAA;IAC7F,CAAC;AACH,CAAC"}