desktopr 1.3.1 → 2.0.1

package/dist-sdk/_companion_context.js

@@ -25,15 +25,20 @@ async function getCacheOnlyWindowContext() {
     if (initialized)
         return;
     initialized = true;
-    if (typeof window === 'undefined' || !window?.Desktopr) {
+    if (typeof window === "undefined" || !window?.Desktopr) {
         console.error("Error executing setupCompanionContext():\nwindow.Desktopr undefined or not yet initialized.");
         return;
     }
-    const windowInfo = await window.Desktopr.window.getInfo();
-    const compState = parseCompanionWindowLabel(windowInfo.label);
-    if (window?.Desktopr?.window?.state)
+    try {
+        const windowInfo = await window.Desktopr.window.getInfo();
+        const compState = parseCompanionWindowLabel(windowInfo.label);
+        state = compState;
         window.Desktopr.window.state = compState;
-    // if(window?.Desktopr?.companion?.state) window.Desktopr.companion.state = compState;
+        // if (window?.Desktopr?.companion?.state) window.Desktopr.companion.state = compState;
+    }
+    catch (error) {
+        console.warn("[Desktopr bridge] Failed to initialize cache-only window context:", error);
+    }
 }
 // Simple getters
 function isCacheOnlyWindow() {

package/dist-sdk/_helpers.js

@@ -36,7 +36,7 @@ __exportStar(require("./modules/rs/worker/_helpers"), exports);
 __exportStar(require("./modules/rs/contextMenu/_helpers"), exports);
 __exportStar(require("./modules/rs/companion/_helpers"), exports);
 __exportStar(require("./modules/rs/globalVariables/_helpers"), exports);
-const utils_1 = require("suffro-lib/utils");
+const utils_1 = require("./utils");
 const tauriReadyCheck = () => (typeof window !== "undefined" && (window.__TAURI__) && (window.Desktopr));
 exports.tauriReadyCheck = tauriReadyCheck;
 const waitTauri = async () => {

package/dist-sdk/desktopr/_helpers.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.platformSpecifcFilter = exports.normalizeString = void 0;
-const utils_1 = require("suffro-lib/utils");
+const utils_1 = require("../utils");
 const normalizeString = (str, options = {
     toLowerCase: true,
     spacesFiller: "",

package/dist-sdk/desktopr/_types.d.ts

@@ -9,12 +9,12 @@ import type { FsInterface } from "../modules/rs/fs/_types";
 import type { MenuInterface } from "../modules/rs/menu/_types";
 import type { DiagnosticsInterface } from "../modules/rs/diagnostics/_types";
 import type { BadgeInterface } from "../modules/rs/badge/_types";
-import type { WorkerInterface } from "../modules/rs/worker/_types";
 import type { ContextMenuInterface } from "../modules/rs/contextMenu/_types";
 import type { AutostartInterface } from "../modules/rs/autostart/_types";
 import type { NetworkInterface } from "../modules/rs/network/_types";
 import type { GlobalVariablesInterface } from "../modules/rs/globalVariables/_types";
 import { WindowTauri } from "../core/_types";
+import { PluginsInterface } from "../modules/rs/plugins/_types";
 export type DtrPlatform = "macos" | "linux" | "windows";
 /**
  * Desktopr API exposed in the webview.
@@ -46,7 +46,7 @@ export type DesktoprAPI = {
     network: NetworkInterface;
     autostart: AutostartInterface;
     badge?: BadgeInterface;
-    worker: WorkerInterface;
+    plugins: PluginsInterface;
     tauri?: WindowTauri;
     onReady: (callback: Function) => void;
     globalVariables: GlobalVariablesInterface;

package/dist-sdk/modules/rs/app/_types.d.ts

@@ -1,5 +1,5 @@
 import { DtrPlatform } from "../../../_types";
-import { I32 } from "suffro-lib/utils";
+import { I32 } from "../../../utils";
 /**
  * Information about a window managed by Desktopr.
  */

package/dist-sdk/modules/rs/badge/_types.d.ts

@@ -1,4 +1,4 @@
-import { U32 } from "suffro-lib/utils";
+import { U32 } from "../../../utils";
 export interface BadgeInterface {
     set: (count: U32) => Promise<void>;
     clear: () => Promise<void>;

package/dist-sdk/modules/rs/contextMenu/_helpers.js

@@ -5,7 +5,7 @@ exports.isCmType = isCmType;
 exports.parseCmType = parseCmType;
 exports.normalizeEntries = normalizeEntries;
 const _helpers_1 = require("../../../_helpers");
-const utils_1 = require("suffro-lib/utils");
+const utils_1 = require("../../../utils");
 // Keep CM_TYPES as a readonly tuple and assert it matches CmType[]
 exports.CM_TYPES = [
     "item",

package/dist-sdk/modules/rs/diagnostics/_helpers.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.diagnosticsSettings = void 0;
 exports.buildDiagnosticsTestFunctions = buildDiagnosticsTestFunctions;
-const utils_1 = require("suffro-lib/utils");
+const utils_1 = require("../../../utils");
 const diagnosticsSettings = async (core, settings) => {
     if (settings?.retentionDaysAnalytics && !utils_1.Num.isU32(settings.retentionDaysAnalytics))
         throw ("[retentionDaysAnalytics] the value must be a U32 integer number");

package/dist-sdk/modules/rs/diagnostics/_types.d.ts

@@ -1,4 +1,4 @@
-import { U32 } from "suffro-lib/utils";
+import { U32 } from "../../../utils";
 export interface DiagnosticsInterface {
     settings: {
         set: (settings?: PrivacySettings) => Promise<unknown>;

package/dist-sdk/modules/rs/files/_types.d.ts

@@ -1,4 +1,4 @@
-import { U64, U8 } from "suffro-lib/utils";
+import { U64, U8 } from "../../../utils";
 export type FileWithBytes = {
     path: string;
     bytes: U8[];

package/dist-sdk/modules/rs/fs/_main.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildFs = buildFs;
+const _helpers_1 = require("../../../_helpers");
 const getWindowLabelIfCompanion = () => {
     const compState = window?.Desktopr?.window
         ?.state;
@@ -10,7 +11,7 @@ const getWindowLabelIfCompanion = () => {
     return label;
 };
 // Comments are in English
-function scope(core, permanent) {
+function scopeCoreMethods(core, permanent, plugin) {
     // Guard that prevents persistent data operations from isolated (companion) windows.
     const ensureDataNotIsolated = () => {
         if (!permanent)
@@ -20,6 +21,7 @@ function scope(core, permanent) {
             throw new Error("Persistent data operations are not available in isolated companion windows. Use the cache scope (Desktopr.fs.cache) for per-session storage.");
         }
     };
+    const pluginStorageModule = ((plugin?.trim()) ?? undefined);
     return {
         listContent: (rel = "") => {
             ensureDataNotIsolated();
@@ -27,6 +29,7 @@ function scope(core, permanent) {
                 rel,
                 permanent,
                 windowLabel: getWindowLabelIfCompanion(),
+                pluginStorageModule
             });
         },
         newDirectory: (rel) => {
@@ -35,6 +38,7 @@ function scope(core, permanent) {
                 rel,
                 permanent,
                 windowLabel: getWindowLabelIfCompanion(),
+                pluginStorageModule
             });
         },
         remove: (rel, recursive = false) => {
@@ -44,6 +48,7 @@ function scope(core, permanent) {
                 recursive,
                 permanent,
                 windowLabel: getWindowLabelIfCompanion(),
+                pluginStorageModule
             });
         },
         stat: (rel = "") => {
@@ -52,6 +57,7 @@ function scope(core, permanent) {
                 rel,
                 permanent,
                 windowLabel: getWindowLabelIfCompanion(),
+                pluginStorageModule
             });
         },
         writeText: (rel, contents, opts) => {
@@ -63,6 +69,7 @@ function scope(core, permanent) {
                 createDirs: opts?.createDirs,
                 append: opts?.append,
                 windowLabel: getWindowLabelIfCompanion(),
+                pluginStorageModule
             });
         },
         readText: (rel) => {
@@ -71,6 +78,7 @@ function scope(core, permanent) {
                 rel,
                 permanent,
                 windowLabel: getWindowLabelIfCompanion(),
+                pluginStorageModule
             });
         },
         writeBytes: (rel, base64, opts) => {
@@ -81,6 +89,7 @@ function scope(core, permanent) {
                 dataBase64: base64,
                 createDirs: opts?.createDirs,
                 windowLabel: getWindowLabelIfCompanion(),
+                pluginStorageModule
             });
         },
         readBytes: (rel) => {
@@ -89,6 +98,7 @@ function scope(core, permanent) {
                 rel,
                 permanent,
                 windowLabel: getWindowLabelIfCompanion(),
+                pluginStorageModule
             });
         },
         exists: (rel) => {
@@ -97,6 +107,7 @@ function scope(core, permanent) {
                 rel,
                 permanent,
                 windowLabel: getWindowLabelIfCompanion(),
+                pluginStorageModule
             });
         },
         move: (src, dest, opts) => {
@@ -108,6 +119,7 @@ function scope(core, permanent) {
                 createDirs: opts?.createDirs,
                 overwrite: opts?.overwrite,
                 windowLabel: getWindowLabelIfCompanion(),
+                pluginStorageModule
             });
         },
         copy: (src, dest, opts) => {
@@ -120,8 +132,26 @@ function scope(core, permanent) {
                 createDirs: opts?.createDirs,
                 overwrite: opts?.overwrite,
                 windowLabel: getWindowLabelIfCompanion(),
+                pluginStorageModule
             });
         },
+    };
+}
+;
+// Comments are in English
+function scope(core, permanent) {
+    // Guard that prevents persistent data operations from isolated (companion) windows.
+    const ensureDataNotIsolated = () => {
+        if (!permanent)
+            return;
+        const label = getWindowLabelIfCompanion();
+        if (label && label.trim().length > 0) {
+            throw new Error("Persistent data operations are not available in isolated companion windows. Use the cache scope (Desktopr.fs.cache) for per-session storage.");
+        }
+    };
+    const coreMethods = scopeCoreMethods(core, permanent);
+    const mainScopeMethods = {
+        ...coreMethods,
         path: async () => {
             ensureDataNotIsolated();
             const p = await core.invoke("dtr_fs_paths");
@@ -136,6 +166,18 @@ function scope(core, permanent) {
         },
         base: permanent ? ".data" : ".cache",
     };
+    return mainScopeMethods;
+}
+function pluginFsScope(core, plugin) {
+    const pluginModuleName = ((plugin?.trim()) ?? undefined);
+    const santizedluginModuleName = ((0, _helpers_1.normalizeModuleName)(pluginModuleName)?.trim()) ?? undefined;
+    if (!santizedluginModuleName)
+        throw ("Invalid plugin name");
+    const coreMethods = scopeCoreMethods(core, true, santizedluginModuleName);
+    return {
+        ...coreMethods,
+        clearStorage: async () => core.invoke("dtr_plugin_storage_clear", { module: santizedluginModuleName })
+    };
 }
 function buildFs(core) {
     const cache = scope(core, false);
@@ -143,6 +185,7 @@ function buildFs(core) {
     return {
         cache,
         data,
+        pluginFs: (plugin) => pluginFsScope(core, plugin),
         paths: async () => core.invoke("dtr_fs_paths"),
         base: { cache: ".cache", data: ".data" },
         trash: {

package/dist-sdk/modules/rs/fs/_types.d.ts

@@ -8,7 +8,7 @@ export type FsPaths = {
     cache: string;
     data: string;
 };
-export type FsScopeMethods = {
+export type FsCoreMethods = {
     listContent: (rel: string) => Promise<FsEntry[]>;
     newDirectory: (rel: string) => Promise<void>;
     remove: (rel: string, recursive?: boolean) => Promise<void>;
@@ -32,10 +32,15 @@ export type FsScopeMethods = {
         createDirs?: boolean;
         overwrite?: boolean;
     }) => Promise<void>;
+};
+export type FsScopeMethods = FsCoreMethods & {
     clear: () => Promise<void>;
     path: () => Promise<string>;
     base: string;
 };
+export type FsPluginMethods = FsCoreMethods & {
+    clearStorage: () => Promise<void>;
+};
 export interface FsTrashMethods {
     clear: () => Promise<void>;
     recover: () => Promise<void>;
@@ -57,6 +62,7 @@ export interface FsDiagnosticMethods {
 export interface FsInterface {
     cache: FsScopeMethods;
     data: FsScopeMethods;
+    pluginFs: (plugin: string) => FsPluginMethods;
     paths: () => Promise<FsPaths>;
     base: {
         cache: string;

package/dist-sdk/modules/rs/menu/_helpers.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initMenuConfig = void 0;
-const utils_1 = require("suffro-lib/utils");
+const utils_1 = require("../../../utils");
 function isMacOS() {
     if (typeof navigator === "undefined") {
         return false;

package/dist-sdk/modules/rs/network/_types.d.ts

@@ -1,4 +1,4 @@
-import { U64 } from "suffro-lib/utils";
+import { U64 } from "../../../utils";
 export interface NetworkInterface {
     status: () => Promise<void>;
     ping: (url: string, timeout?: U64) => Promise<void>;

package/dist-sdk/modules/rs/plugins/_helpers.d.ts

@@ -0,0 +1 @@
+export declare const normalizeModuleName: (name: string) => string;

package/dist-sdk/modules/rs/plugins/_helpers.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeModuleName = void 0;
+const normalizeModuleName = (name) => {
+    const sanitizeWasmExtensions = name.replaceAll(".wasm", "");
+    const addWasmExtensions = `${sanitizeWasmExtensions}.wasm`;
+    return addWasmExtensions;
+};
+exports.normalizeModuleName = normalizeModuleName;

package/dist-sdk/modules/rs/plugins/_main.d.ts

@@ -0,0 +1,5 @@
+import { DesktoprAPI } from "../../../_types";
+import { PluginsInterface } from "./_types";
+export declare function buildPlugins(core: {
+    invoke: DesktoprAPI["invoke"];
+}): PluginsInterface;

package/dist-sdk/modules/rs/plugins/_main.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPlugins = buildPlugins;
+const _helpers_1 = require("./_helpers");
+function buildPlugins(core) {
+    return {
+        call: (module, payload, timeoutMs) => core.invoke("dtr_plugin_call", { module: (0, _helpers_1.normalizeModuleName)(module), payload, timeoutMs }),
+        status: () => core.invoke("dtr_plugin_status"),
+        list: () => core.invoke("dtr_plugin_list_modules"),
+        remove: (name) => core.invoke("dtr_plugin_remove_module", { name: (0, _helpers_1.normalizeModuleName)(name) }),
+        addFromBytes: (name, contents) => core.invoke("dtr_plugin_add_module", { name: (0, _helpers_1.normalizeModuleName)(name), contents }),
+        add: (name, maxBytes) => core.invoke("dtr_plugin_pick_and_add_module", { maxBytes, defaultName: (0, _helpers_1.normalizeModuleName)(name) }),
+        killJobs: () => core.invoke("dtr_plugin_clear_all_jobs")
+    };
+}

package/dist-sdk/modules/rs/plugins/_types.d.ts

@@ -0,0 +1,38 @@
+import { U64, U8 } from "../../../utils";
+export interface PluginsInterface {
+    call: (module: string, payload: PluginCallPayload, timeoutMs?: U64) => Promise<PluginCallResult>;
+    status: () => Promise<PluginStatusResult>;
+    list: () => Promise<string[]>;
+    remove: (name: string) => Promise<boolean>;
+    addFromBytes: (name: string, contents: U8[]) => Promise<any>;
+    add: (name: string, maxBytes?: U64 | undefined) => Promise<PluginAddResult>;
+    killJobs: () => Promise<boolean>;
+}
+export type PluginCallPayload = {
+    fn: string;
+    args: number[] | Record<string, unknown>;
+    [key: string]: any;
+};
+export type PluginStatusResult = {
+    ready: true;
+    runtime: string;
+};
+export type PluginCallResult = {
+    durationMs: number;
+    error: string | null | undefined;
+    id: string;
+    ok: boolean;
+    stderr: string;
+    stdout: string;
+    value: {
+        error?: string;
+        value?: string | number;
+        ok: boolean;
+    };
+};
+export type PluginAddResult = {
+    bytes: number;
+    name: string;
+    path: string;
+    saved: boolean;
+};

package/dist-sdk/modules/rs/plugins/_types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-sdk/modules/rs/window/_helpers.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.closeWindow = exports.newWindow = exports.waitTauri = exports.tauriReadyCheck = void 0;
 const sdk_1 = require("../../../sdk");
 const _constants_1 = require("../../../_constants");
-const utils_1 = require("suffro-lib/utils");
+const utils_1 = require("../../../utils");
 const tauriReadyCheck = () => typeof window !== "undefined" &&
     window.__TAURI__ &&
     window.Desktopr;

package/dist-sdk/modules/rs/window/_main.js

@@ -6,11 +6,6 @@ const _helpers_2 = require("./_helpers");
 function buildWindow(core) {
     const randomWindowLabel = `w_${Math.random().toString(36).substring(2, 2 + 8)}`;
     return {
-        devTools: {
-            toggle: (label) => core.invoke("dtr_toggle_devtools", { label: label ?? "main" }),
-            open: (label) => core.invoke("dtr_open_devtools", { label: label ?? "main" }),
-            close: (label) => core.invoke("dtr_close_devtools", { label: label ?? "main" }),
-        },
         minimize: (label) => core.invoke("dtr_win_minimize", { label: label ?? "main" }),
         maximizeToggle: (label) => core.invoke("dtr_win_maximize", { label: label ?? "main" }),
         fullscreen: (enable, label) => core.invoke("dtr_win_fullscreen", { enable, label: label ?? "main" }),

package/dist-sdk/modules/rs/window/_types.d.ts

@@ -1,11 +1,6 @@
 import { CompanionState } from "../../../_companion_context";
 export type _WindowTypesPlaceholder = unknown;
 export interface WindowInterface {
-    devTools: {
-        toggle: (label?: string) => Promise<void>;
-        open: (label?: string) => Promise<void>;
-        close: (label?: string) => Promise<void>;
-    };
     new: (options?: NewWindowOptions) => Promise<void>;
     close: (label: string) => Promise<void>;
     minimize: () => Promise<void>;

package/dist-sdk/modules/rs/worker/_main.d.ts

@@ -1,5 +1,5 @@
 import { DesktoprAPI } from "../../../_types";
-import { U64, U8 } from "suffro-lib/utils";
+import { U64, U8 } from "../../../utils";
 import { WorkerCallPayload } from "./_types";
 export declare function buildWorker(core: {
     invoke: DesktoprAPI["invoke"];

package/dist-sdk/modules/rs/worker/_types.d.ts

@@ -1,4 +1,4 @@
-import { U64, U8 } from "suffro-lib/utils";
+import { U64, U8 } from "../../../utils";
 export interface WorkerInterface {
     call: (method: string, payload: WorkerCallPayload, timeoutMs?: U64) => Promise<string>;
     status: () => Promise<boolean>;

package/dist-sdk/utils/crypto/_crypto.d.ts

@@ -0,0 +1,31 @@
+declare function digestHex(input: string, algorithm: "SHA-1" | "SHA-256" | "SHA-512"): Promise<string>;
+declare function hmacSha256Hex(key: string, message: string): Promise<string>;
+/**
+ * Simple  32-bit hash for change detection.
+ * Do NOT use for security-sensitive purposes.
+ */
+export declare function nonCryptographicHash(input: string): string;
+export declare function sha256(input: string, nonCryptographicFallback?: boolean): Promise<string>;
+declare function encodeBase64(input: string): string;
+declare function decodeBase64(base64: string): string;
+declare function generateRandomInitializationVector(): Uint8Array;
+declare function aesGcmEncrypt(plaintext: string, key: CryptoKey, iv: BufferSource): Promise<Uint8Array>;
+declare function aesGcmDecrypt(ciphertext: BufferSource, key: CryptoKey, iv: BufferSource): Promise<string>;
+export declare const cryptoTools: {
+    digest: {
+        digestHex: typeof digestHex;
+        sha256: typeof sha256;
+        hmacSha256Hex: typeof hmacSha256Hex;
+        nonCryptographicHash: typeof nonCryptographicHash;
+    };
+    base64: {
+        encode: typeof encodeBase64;
+        decode: typeof decodeBase64;
+    };
+    AES: {
+        encode: typeof aesGcmEncrypt;
+        decode: typeof aesGcmDecrypt;
+        randomInitializationVector: typeof generateRandomInitializationVector;
+    };
+};
+export {};

package/dist-sdk/utils/crypto/_crypto.js

@@ -0,0 +1,116 @@
+"use strict";
+// encryption-utils.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cryptoTools = void 0;
+exports.nonCryptographicHash = nonCryptographicHash;
+exports.sha256 = sha256;
+// ==============================
+// 🔒 Hash / Digest
+// ==============================
+async function digestHex(input, algorithm) {
+    const data = new TextEncoder().encode(input);
+    const hash = await crypto.subtle.digest(algorithm, data);
+    return Array.from(new Uint8Array(hash))
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+// ==============================
+// 🔐 HMAC (digest con chiave)
+// ==============================
+async function hmacSha256Hex(key, message) {
+    const enc = new TextEncoder();
+    const keyData = enc.encode(key);
+    const msgData = enc.encode(message);
+    const cryptoKey = await crypto.subtle.importKey("raw", keyData, { name: "HMAC", hash: { name: "SHA-256" } }, false, ["sign"]);
+    const signature = await crypto.subtle.sign("HMAC", cryptoKey, msgData);
+    return Array.from(new Uint8Array(signature))
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+/**
+ * Simple  32-bit hash for change detection.
+ * Do NOT use for security-sensitive purposes.
+ */
+function nonCryptographicHash(input) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        hash = (hash * 31 + input.charCodeAt(i)) | 0;
+    }
+    // convert to unsigned and hex
+    return (hash >>> 0).toString(16);
+}
+async function sha256(input, nonCryptographicFallback = true) {
+    if (typeof crypto === "undefined" || !crypto.subtle) {
+        if (!nonCryptographicFallback)
+            throw "crypto not found in this contex";
+        console.warn(`[crypto not found] using unsafe non-cryptographic fallback, useful only as weak "checksum"`);
+        return nonCryptographicHash(input);
+    }
+    const encoder = new TextEncoder();
+    const data = encoder.encode(input);
+    const digest = await crypto.subtle.digest("SHA-256", data);
+    const bytes = new Uint8Array(digest);
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+// ==============================
+// 📦 Base64
+// ==============================
+function encodeBase64(input) {
+    const bytes = new TextEncoder().encode(input);
+    let binary = "";
+    const chunkSize = 0x8000; // 32 KB per evitare troppi argomenti a String.fromCharCode
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        const chunk = bytes.subarray(i, i + chunkSize);
+        binary += String.fromCharCode(...chunk);
+    }
+    return btoa(binary);
+}
+function decodeBase64(base64) {
+    const binary = atob(base64);
+    const len = binary.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return new TextDecoder().decode(bytes);
+}
+// ==============================
+// 🔐 AES-GCM (reversibile)
+// ==============================
+async function generateAesKey() {
+    return crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, true, [
+        "encrypt",
+        "decrypt",
+    ]);
+}
+function generateRandomInitializationVector() {
+    return crypto.getRandomValues(new Uint8Array(12)); // 96-bit IV
+}
+async function aesGcmEncrypt(plaintext, key, iv) {
+    const encoded = new TextEncoder().encode(plaintext);
+    const ciphertext = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, encoded);
+    return new Uint8Array(ciphertext);
+}
+async function aesGcmDecrypt(ciphertext, key, iv) {
+    const decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
+    return new TextDecoder().decode(decrypted);
+}
+exports.cryptoTools = {
+    digest: {
+        digestHex,
+        sha256,
+        hmacSha256Hex,
+        nonCryptographicHash
+    },
+    base64: {
+        encode: encodeBase64,
+        decode: decodeBase64,
+    },
+    AES: {
+        encode: aesGcmEncrypt,
+        decode: aesGcmDecrypt,
+        randomInitializationVector: generateRandomInitializationVector,
+    },
+};

package/dist-sdk/utils/crypto/index.d.ts

@@ -0,0 +1 @@
+export * from "./_crypto";

package/dist-sdk/utils/crypto/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./_crypto"), exports);

package/dist-sdk/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils";
+export * from "./crypto";

package/dist-sdk/utils/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils"), exports);
+__exportStar(require("./crypto"), exports);