@ericsanchezok/synergy-util 3.0.1 → 3.0.3

package/dist/plugin-policy.d.ts

@@ -9,6 +9,8 @@ export interface RuntimeLimits {
     taskRunTimeoutMs: number;
     shutdownGraceMs: number;
     heartbeatIntervalMs: number;
+    maxMemoryMb: number;
+    memorySampleIntervalMs: number;
 }
 export type RuntimeLimitOverrides = Partial<RuntimeLimits>;
 export interface PluginRuntimePolicyInput {

package/dist/plugin-policy.js

@@ -6,6 +6,8 @@ export const DEFAULT_PLUGIN_RUNTIME_LIMITS = {
     taskRunTimeoutMs: 120_000,
     shutdownGraceMs: 1_500,
     heartbeatIntervalMs: 5_000,
+    maxMemoryMb: 512,
+    memorySampleIntervalMs: 5_000,
 };
 export function resolveRuntimeMode(input) {
     return input.source === "builtin" ? "inProcess" : "process";

package/dist/uuid.d.ts

@@ -7,4 +7,10 @@ export interface UUIDEnvironment {
     now?: () => number;
     random?: () => number;
 }
+export declare class SecureRandomUnavailableError extends Error {
+    constructor();
+}
+export declare function generateRandomBytes(length: number, environment?: UUIDEnvironment): Uint8Array;
+export declare function generateSecureRandomBytes(length: number, environment?: UUIDEnvironment): Uint8Array;
+export declare function generateSecureUUID(environment?: UUIDEnvironment): string;
 export declare function generateUUID(environment?: UUIDEnvironment): string;

package/dist/uuid.js

@@ -1,3 +1,46 @@
+export class SecureRandomUnavailableError extends Error {
+    constructor() {
+        super("Secure randomness requires a usable Web Crypto implementation");
+        this.name = "SecureRandomUnavailableError";
+    }
+}
+export function generateRandomBytes(length, environment) {
+    const bytes = new Uint8Array(length);
+    const webCrypto = environment ? environment.crypto : globalThis.crypto;
+    try {
+        if (typeof webCrypto?.getRandomValues === "function")
+            return webCrypto.getRandomValues(bytes);
+    }
+    catch {
+        // Ordinary identifiers may use the weak fallback when Web Crypto is unavailable.
+    }
+    const random = environment?.random ?? Math.random;
+    for (let index = 0; index < bytes.length; index++)
+        bytes[index] = Math.floor(random() * 256);
+    return bytes;
+}
+export function generateSecureRandomBytes(length, environment) {
+    const webCrypto = environment ? environment.crypto : globalThis.crypto;
+    if (typeof webCrypto?.getRandomValues !== "function")
+        throw new SecureRandomUnavailableError();
+    try {
+        return webCrypto.getRandomValues(new Uint8Array(length));
+    }
+    catch {
+        throw new SecureRandomUnavailableError();
+    }
+}
+export function generateSecureUUID(environment) {
+    const webCrypto = environment ? environment.crypto : globalThis.crypto;
+    try {
+        if (typeof webCrypto?.randomUUID === "function")
+            return webCrypto.randomUUID();
+    }
+    catch {
+        // Fall through to strict getRandomValues without a weak fallback.
+    }
+    return formatUUID(generateSecureRandomBytes(16, environment));
+}
 let fallbackCounter = 0;
 export function generateUUID(environment) {
     const webCrypto = environment ? environment.crypto : globalThis.crypto;
@@ -9,12 +52,8 @@ export function generateUUID(environment) {
         // randomUUID may be exposed but blocked outside a secure context.
     }
     try {
-        if (typeof webCrypto?.getRandomValues === "function") {
-            const bytes = webCrypto.getRandomValues(new Uint8Array(16));
-            bytes[6] = (bytes[6] & 0x0f) | 0x40;
-            bytes[8] = (bytes[8] & 0x3f) | 0x80;
-            return formatUUID(bytes);
-        }
+        if (typeof webCrypto?.getRandomValues === "function")
+            return formatUUID(generateSecureRandomBytes(16, environment));
     }
     catch {
         // Fall through for runtimes without a usable Web Crypto implementation.
@@ -25,6 +64,8 @@ export function generateUUID(environment) {
     return `${now.toString(36)}-${fallbackCounter.toString(36)}-${random.toString(36).slice(2)}`;
 }
 function formatUUID(bytes) {
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
     const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
     return [hex.slice(0, 8), hex.slice(8, 12), hex.slice(12, 16), hex.slice(16, 20), hex.slice(20)].join("-");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericsanchezok/synergy-util",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "type": "module",
   "license": "MIT",
   "exports": {