actly 1.2.0 → 1.3.0

package/dist/utils/decorator.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePolicy = usePolicy;
+function usePolicy(options) {
+    return function (_target, propertyKey, descriptor) {
+        if (!descriptor || !descriptor.value) {
+            throw new Error(`Actly: @usePolicy can only be applied to methods with a function value. ` +
+                `Got descriptor without value for property "${String(propertyKey)}".`);
+        }
+        const originalMethod = descriptor.value;
+        let actPromise;
+        const getAct = () => {
+            if (!actPromise)
+                actPromise = Promise.resolve().then(() => require('../core/act.js')).then(m => m.act);
+            return actPromise;
+        };
+        const wrappedMethod = async function (...args) {
+            const act = await getAct();
+            const ctorName = this?.constructor?.name ?? 'Anonymous';
+            const key = `${ctorName}.${String(propertyKey)}`;
+            const firstArg = args[0];
+            const isSignal = firstArg != null &&
+                typeof firstArg === 'object' &&
+                typeof firstArg.aborted === 'boolean' &&
+                typeof firstArg.addEventListener === 'function';
+            const signal = isSignal ? firstArg : undefined;
+            const fnArgs = signal ? args.slice(1) : args;
+            const result = await act(key, async (actSignal) => originalMethod.apply(this, [actSignal, ...fnArgs]), signal ? { ...options, signal } : options);
+            if (result.ok)
+                return result.value;
+            throw result.error;
+        };
+        try {
+            Object.defineProperty(wrappedMethod, 'name', {
+                value: typeof propertyKey === 'symbol' ? propertyKey.description ?? 'wrapped' : propertyKey,
+                configurable: true,
+            });
+        }
+        catch {
+        }
+        descriptor.value = wrappedMethod;
+        return descriptor;
+    };
+}

package/dist/utils/decorator.d.ts

@@ -0,0 +1,3 @@
+import type { ActOptions } from '../types/index.js';
+export declare function usePolicy(options: ActOptions): MethodDecorator;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/utils/decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../src/utils/decorator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,mBAAmB,CAAA;AA0B9D,wBAAgB,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,eAAe,CAoE9D"}

package/dist/utils/decorator.js

@@ -0,0 +1,41 @@
+export function usePolicy(options) {
+    return function (_target, propertyKey, descriptor) {
+        if (!descriptor || !descriptor.value) {
+            throw new Error(`Actly: @usePolicy can only be applied to methods with a function value. ` +
+                `Got descriptor without value for property "${String(propertyKey)}".`);
+        }
+        const originalMethod = descriptor.value;
+        let actPromise;
+        const getAct = () => {
+            if (!actPromise)
+                actPromise = import('../core/act.js').then(m => m.act);
+            return actPromise;
+        };
+        const wrappedMethod = async function (...args) {
+            const act = await getAct();
+            const ctorName = this?.constructor?.name ?? 'Anonymous';
+            const key = `${ctorName}.${String(propertyKey)}`;
+            const firstArg = args[0];
+            const isSignal = firstArg != null &&
+                typeof firstArg === 'object' &&
+                typeof firstArg.aborted === 'boolean' &&
+                typeof firstArg.addEventListener === 'function';
+            const signal = isSignal ? firstArg : undefined;
+            const fnArgs = signal ? args.slice(1) : args;
+            const result = await act(key, async (actSignal) => originalMethod.apply(this, [actSignal, ...fnArgs]), signal ? { ...options, signal } : options);
+            if (result.ok)
+                return result.value;
+            throw result.error;
+        };
+        try {
+            Object.defineProperty(wrappedMethod, 'name', {
+                value: typeof propertyKey === 'symbol' ? propertyKey.description ?? 'wrapped' : propertyKey,
+                configurable: true,
+            });
+        }
+        catch {
+        }
+        descriptor.value = wrappedMethod;
+        return descriptor;
+    };
+}

package/dist/utils/key.cjs

@@ -1,50 +1,23 @@
 "use strict";
-/**
- * Key sanitisation — the first line of defence against:
- *
- *  - **Prototype pollution**: `__proto__`, `constructor`, `prototype` as keys
- *    bypass namespace isolation in plain-object store adapters.
- *  - **Control-char injection**: `\x00`–`\x1f`, `\x7f` break some store
- *    backends (Redis Lua, HTTP header logs, JSON-LD contexts).
- *  - **CRLF injection**: `\r\n` in keys can break naive log/HTTP serializers.
- *  - **Memory exhaustion**: unbounded key length lets a caller store a 10MB
- *    string as a key, bloating the store and blocking iteration.
- *  - **Namespace collision**: user keys starting with `dedupe:`, `cache:`,
- *    or `__inflight:` would clobber internal slots.
- *
- * # Why a dedicated module?
- *
- * Key validation is security-sensitive. Centralising it here means every
- * call site (`act()`, `invalidate()`, `withStore().invalidate()`) applies
- * the same rules. Local inlining risks drift.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sanitizeKey = sanitizeKey;
 const limits_js_1 = require("./limits.js");
-const RESERVED_PREFIXES = ['dedupe:', 'cache:', '__inflight:', '__tenant:', 'tenant:'];
-/**
- * Strings that, if used as Map keys, are safe — but if used as plain-object
- * keys (e.g. a naive store adapter) enable prototype pollution. Reject them
- * regardless of store type: the contract is "your key is safe everywhere".
- */
-const FORBIDDEN_LITERALS = new Set(['__proto__', 'constructor', 'prototype']);
-/**
- * Reject any character in the C0 control range, DEL (0x7f), or CRLF.
- * Allow TAB (0x09) and LF (0x0a) since some callers embed newlines in
- * structured keys legitimately — but CR is always forbidden.
- */
+const RESERVED_PREFIXES = ['dedupe:', 'cache:', 'inflight:', 'tenant:'];
+const FORBIDDEN_LITERALS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+    'hasOwnProperty',
+    'toString',
+    'valueOf',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    'toLocaleString',
+]);
 const UNSAFE_CHAR = /[\x00-\x08\x0b\x0c\x0d\x0e-\x1f\x7f]/;
-/**
- * Validate a user-supplied key. Throws synchronously on invalid input.
- *
- * Programmer errors throw — they must not be swallowed into an `ActFailure`
- * because the caller's code is broken.
- *
- * @returns the same `key` (for chaining); never transforms it.
- */
 function sanitizeKey(key) {
     if (typeof key !== 'string') {
-        throw new TypeError(`Actly: key must be a string, got ${typeName(key)}`);
+        throw new TypeError(`Actly: key must be a string, got ${key === null ? 'null' : typeof key}`);
     }
     if (key.length === 0) {
         throw new RangeError("Actly: key must be non-empty. An empty key collapses every caller " +
@@ -70,8 +43,3 @@ function sanitizeKey(key) {
     }
     return key;
 }
-function typeName(v) {
-    if (v === null)
-        return 'null';
-    return typeof v;
-}

package/dist/utils/key.d.ts

@@ -1,29 +1,2 @@
-/**
- * Key sanitisation — the first line of defence against:
- *
- *  - **Prototype pollution**: `__proto__`, `constructor`, `prototype` as keys
- *    bypass namespace isolation in plain-object store adapters.
- *  - **Control-char injection**: `\x00`–`\x1f`, `\x7f` break some store
- *    backends (Redis Lua, HTTP header logs, JSON-LD contexts).
- *  - **CRLF injection**: `\r\n` in keys can break naive log/HTTP serializers.
- *  - **Memory exhaustion**: unbounded key length lets a caller store a 10MB
- *    string as a key, bloating the store and blocking iteration.
- *  - **Namespace collision**: user keys starting with `dedupe:`, `cache:`,
- *    or `__inflight:` would clobber internal slots.
- *
- * # Why a dedicated module?
- *
- * Key validation is security-sensitive. Centralising it here means every
- * call site (`act()`, `invalidate()`, `withStore().invalidate()`) applies
- * the same rules. Local inlining risks drift.
- */
-/**
- * Validate a user-supplied key. Throws synchronously on invalid input.
- *
- * Programmer errors throw — they must not be swallowed into an `ActFailure`
- * because the caller's code is broken.
- *
- * @returns the same `key` (for chaining); never transforms it.
- */
 export declare function sanitizeKey(key: string): string;
 //# sourceMappingURL=key.d.ts.map

package/dist/utils/key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../src/utils/key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAoBH;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAqC/C"}
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../src/utils/key.ts"],"names":[],"mappings":"AAwCA,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAqC/C"}

package/dist/utils/key.js

@@ -1,47 +1,20 @@
-/**
- * Key sanitisation — the first line of defence against:
- *
- *  - **Prototype pollution**: `__proto__`, `constructor`, `prototype` as keys
- *    bypass namespace isolation in plain-object store adapters.
- *  - **Control-char injection**: `\x00`–`\x1f`, `\x7f` break some store
- *    backends (Redis Lua, HTTP header logs, JSON-LD contexts).
- *  - **CRLF injection**: `\r\n` in keys can break naive log/HTTP serializers.
- *  - **Memory exhaustion**: unbounded key length lets a caller store a 10MB
- *    string as a key, bloating the store and blocking iteration.
- *  - **Namespace collision**: user keys starting with `dedupe:`, `cache:`,
- *    or `__inflight:` would clobber internal slots.
- *
- * # Why a dedicated module?
- *
- * Key validation is security-sensitive. Centralising it here means every
- * call site (`act()`, `invalidate()`, `withStore().invalidate()`) applies
- * the same rules. Local inlining risks drift.
- */
 import { LIMITS } from './limits.js';
-const RESERVED_PREFIXES = ['dedupe:', 'cache:', '__inflight:', '__tenant:', 'tenant:'];
-/**
- * Strings that, if used as Map keys, are safe — but if used as plain-object
- * keys (e.g. a naive store adapter) enable prototype pollution. Reject them
- * regardless of store type: the contract is "your key is safe everywhere".
- */
-const FORBIDDEN_LITERALS = new Set(['__proto__', 'constructor', 'prototype']);
-/**
- * Reject any character in the C0 control range, DEL (0x7f), or CRLF.
- * Allow TAB (0x09) and LF (0x0a) since some callers embed newlines in
- * structured keys legitimately — but CR is always forbidden.
- */
+const RESERVED_PREFIXES = ['dedupe:', 'cache:', 'inflight:', 'tenant:'];
+const FORBIDDEN_LITERALS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+    'hasOwnProperty',
+    'toString',
+    'valueOf',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    'toLocaleString',
+]);
 const UNSAFE_CHAR = /[\x00-\x08\x0b\x0c\x0d\x0e-\x1f\x7f]/;
-/**
- * Validate a user-supplied key. Throws synchronously on invalid input.
- *
- * Programmer errors throw — they must not be swallowed into an `ActFailure`
- * because the caller's code is broken.
- *
- * @returns the same `key` (for chaining); never transforms it.
- */
 export function sanitizeKey(key) {
     if (typeof key !== 'string') {
-        throw new TypeError(`Actly: key must be a string, got ${typeName(key)}`);
+        throw new TypeError(`Actly: key must be a string, got ${key === null ? 'null' : typeof key}`);
     }
     if (key.length === 0) {
         throw new RangeError("Actly: key must be non-empty. An empty key collapses every caller " +
@@ -67,9 +40,3 @@ export function sanitizeKey(key) {
     }
     return key;
 }
-function typeName(v) {
-    if (v === null)
-        return 'null';
-    return typeof v;
-}
-//# sourceMappingURL=key.js.map

package/dist/utils/limits.cjs

@@ -1,40 +1,22 @@
 "use strict";
-/**
- * Centralised numeric limits for all actly inputs.
- *
- * # Why central?
- *
- * Every numeric input that flows into actly (retry.attempts, timeout.ms,
- * cache.ttl, etc.) must be bounded to prevent:
- *  - memory exhaustion (e.g. `cache: { ttl: 1e15 }` → 31 700-year TTL)
- *  - CPU exhaustion (e.g. `retry: { attempts: 1e9 }`)
- *  - timer overflow (e.g. `setTimeout(fn, 1e16)` wraps to 1ms on some engines)
- *
- * The values are deliberately generous: they prevent pathological abuse,
- * not legitimate use. If you need to exceed one of these limits, you almost
- * certainly have a bug.
- *
- * These limits are constants — they are not runtime-configurable. If you
- * need different limits, fork the source or wrap `act()` with your own
- * validation layer.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIMITS = void 0;
 exports.LIMITS = Object.freeze({
-    /** Maximum key length in characters. Prevents multi-MB keys bloating stores. */
     MAX_KEY_LENGTH: 1024,
-    /** Hard ceiling on `retry.attempts`. 100 attempts ≈ 100 fn invocations. */
     MAX_RETRY_ATTEMPTS: 100,
-    /** Maximum per-attempt / total timeout in ms. ~27 hours. */
     MAX_TIMEOUT_MS: 100_000_000,
-    /** Maximum cache TTL in ms. ~24 hours. */
     MAX_CACHE_TTL: 86_400_000,
-    /** Maximum delay between retries in ms. ~5 minutes. */
     MAX_RETRY_DELAY_MS: 300_000,
-    /** Maximum dedupe inflightTtl in ms. ~24 hours. */
     MAX_INFLIGHT_TTL: 86_400_000,
-    /** Default bound for InMemoryStore when used as the module-level default. */
+    DEFAULT_INFLIGHT_TTL: 5 * 60_000,
     DEFAULT_STORE_MAX_SIZE: 10_000,
-    /** Background sweep interval for the default store. */
     DEFAULT_STORE_CLEANUP_INTERVAL_MS: 60_000,
+    MAX_GLOBAL_INFLIGHT: 100_000,
+    MAX_CIRCUIT_BREAKER_WINDOW: 1_000_000,
+    MAX_BULKHEAD_CONCURRENCY: 1_000_000,
+    MAX_BULKHEAD_QUEUE: 1_000_000,
+    MAX_RATE_LIMIT_CALLS: 1_000_000,
+    MAX_SANITIZED_ERROR_LENGTH: 8_192,
+    MAX_HEDGE_DELAY_MS: 300_000,
+    MAX_TENANTS: 10_000,
 });

package/dist/utils/limits.d.ts

@@ -1,39 +1,21 @@
-/**
- * Centralised numeric limits for all actly inputs.
- *
- * # Why central?
- *
- * Every numeric input that flows into actly (retry.attempts, timeout.ms,
- * cache.ttl, etc.) must be bounded to prevent:
- *  - memory exhaustion (e.g. `cache: { ttl: 1e15 }` → 31 700-year TTL)
- *  - CPU exhaustion (e.g. `retry: { attempts: 1e9 }`)
- *  - timer overflow (e.g. `setTimeout(fn, 1e16)` wraps to 1ms on some engines)
- *
- * The values are deliberately generous: they prevent pathological abuse,
- * not legitimate use. If you need to exceed one of these limits, you almost
- * certainly have a bug.
- *
- * These limits are constants — they are not runtime-configurable. If you
- * need different limits, fork the source or wrap `act()` with your own
- * validation layer.
- */
 export declare const LIMITS: Readonly<{
-    /** Maximum key length in characters. Prevents multi-MB keys bloating stores. */
     MAX_KEY_LENGTH: 1024;
-    /** Hard ceiling on `retry.attempts`. 100 attempts ≈ 100 fn invocations. */
     MAX_RETRY_ATTEMPTS: 100;
-    /** Maximum per-attempt / total timeout in ms. ~27 hours. */
     MAX_TIMEOUT_MS: 100000000;
-    /** Maximum cache TTL in ms. ~24 hours. */
     MAX_CACHE_TTL: 86400000;
-    /** Maximum delay between retries in ms. ~5 minutes. */
     MAX_RETRY_DELAY_MS: 300000;
-    /** Maximum dedupe inflightTtl in ms. ~24 hours. */
     MAX_INFLIGHT_TTL: 86400000;
-    /** Default bound for InMemoryStore when used as the module-level default. */
+    DEFAULT_INFLIGHT_TTL: number;
     DEFAULT_STORE_MAX_SIZE: 10000;
-    /** Background sweep interval for the default store. */
     DEFAULT_STORE_CLEANUP_INTERVAL_MS: 60000;
+    MAX_GLOBAL_INFLIGHT: 100000;
+    MAX_CIRCUIT_BREAKER_WINDOW: 1000000;
+    MAX_BULKHEAD_CONCURRENCY: 1000000;
+    MAX_BULKHEAD_QUEUE: 1000000;
+    MAX_RATE_LIMIT_CALLS: 1000000;
+    MAX_SANITIZED_ERROR_LENGTH: 8192;
+    MAX_HEDGE_DELAY_MS: 300000;
+    MAX_TENANTS: 10000;
 }>;
 export type Limits = typeof LIMITS;
 //# sourceMappingURL=limits.d.ts.map

package/dist/utils/limits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../src/utils/limits.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,MAAM;IACjB,gFAAgF;;IAGhF,2EAA2E;;IAG3E,4DAA4D;;IAG5D,0CAA0C;;IAG1C,uDAAuD;;IAGvD,mDAAmD;;IAGnD,6EAA6E;;IAG7E,uDAAuD;;EAEvD,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAA"}
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../src/utils/limits.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;EA8EjB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAA"}

package/dist/utils/limits.js

@@ -1,38 +1,19 @@
-/**
- * Centralised numeric limits for all actly inputs.
- *
- * # Why central?
- *
- * Every numeric input that flows into actly (retry.attempts, timeout.ms,
- * cache.ttl, etc.) must be bounded to prevent:
- *  - memory exhaustion (e.g. `cache: { ttl: 1e15 }` → 31 700-year TTL)
- *  - CPU exhaustion (e.g. `retry: { attempts: 1e9 }`)
- *  - timer overflow (e.g. `setTimeout(fn, 1e16)` wraps to 1ms on some engines)
- *
- * The values are deliberately generous: they prevent pathological abuse,
- * not legitimate use. If you need to exceed one of these limits, you almost
- * certainly have a bug.
- *
- * These limits are constants — they are not runtime-configurable. If you
- * need different limits, fork the source or wrap `act()` with your own
- * validation layer.
- */
 export const LIMITS = Object.freeze({
-    /** Maximum key length in characters. Prevents multi-MB keys bloating stores. */
     MAX_KEY_LENGTH: 1024,
-    /** Hard ceiling on `retry.attempts`. 100 attempts ≈ 100 fn invocations. */
     MAX_RETRY_ATTEMPTS: 100,
-    /** Maximum per-attempt / total timeout in ms. ~27 hours. */
     MAX_TIMEOUT_MS: 100_000_000,
-    /** Maximum cache TTL in ms. ~24 hours. */
     MAX_CACHE_TTL: 86_400_000,
-    /** Maximum delay between retries in ms. ~5 minutes. */
     MAX_RETRY_DELAY_MS: 300_000,
-    /** Maximum dedupe inflightTtl in ms. ~24 hours. */
     MAX_INFLIGHT_TTL: 86_400_000,
-    /** Default bound for InMemoryStore when used as the module-level default. */
+    DEFAULT_INFLIGHT_TTL: 5 * 60_000,
     DEFAULT_STORE_MAX_SIZE: 10_000,
-    /** Background sweep interval for the default store. */
     DEFAULT_STORE_CLEANUP_INTERVAL_MS: 60_000,
+    MAX_GLOBAL_INFLIGHT: 100_000,
+    MAX_CIRCUIT_BREAKER_WINDOW: 1_000_000,
+    MAX_BULKHEAD_CONCURRENCY: 1_000_000,
+    MAX_BULKHEAD_QUEUE: 1_000_000,
+    MAX_RATE_LIMIT_CALLS: 1_000_000,
+    MAX_SANITIZED_ERROR_LENGTH: 8_192,
+    MAX_HEDGE_DELAY_MS: 300_000,
+    MAX_TENANTS: 10_000,
 });
-//# sourceMappingURL=limits.js.map

package/dist/utils/safeCall.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeCall = safeCall;
+const IS_DEV = typeof process !== 'undefined' &&
+    typeof process.env === 'object' &&
+    process.env !== null &&
+    process.env.NODE_ENV !== 'production';
+function safeCall(fn, ...args) {
+    if (!fn)
+        return;
+    try {
+        const result = fn(...args);
+        if (result !== null && result !== undefined && typeof result.then === 'function') {
+            Promise.resolve(result).catch((err) => {
+                if (IS_DEV) {
+                    console.warn('Actly: async observability hook rejected — error swallowed to protect main path. ' +
+                        'Fix the hook to prevent silent observability loss.', err);
+                }
+            });
+        }
+    }
+    catch (err) {
+        if (IS_DEV) {
+            console.warn('Actly: observability hook threw — error swallowed to protect main path. ' +
+                'Fix the hook to prevent silent observability loss.', err);
+        }
+    }
+}

package/dist/utils/safeCall.d.ts

@@ -0,0 +1,2 @@
+export declare function safeCall<T extends unknown[]>(fn: ((...args: T) => void) | undefined, ...args: T): void;
+//# sourceMappingURL=safeCall.d.ts.map

package/dist/utils/safeCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeCall.d.ts","sourceRoot":"","sources":["../../src/utils/safeCall.ts"],"names":[],"mappings":"AAkBA,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,EAC1C,EAAE,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,EACtC,GAAG,IAAI,EAAE,CAAC,GACT,IAAI,CA2BN"}

package/dist/utils/safeCall.js

@@ -0,0 +1,25 @@
+const IS_DEV = typeof process !== 'undefined' &&
+    typeof process.env === 'object' &&
+    process.env !== null &&
+    process.env.NODE_ENV !== 'production';
+export function safeCall(fn, ...args) {
+    if (!fn)
+        return;
+    try {
+        const result = fn(...args);
+        if (result !== null && result !== undefined && typeof result.then === 'function') {
+            Promise.resolve(result).catch((err) => {
+                if (IS_DEV) {
+                    console.warn('Actly: async observability hook rejected — error swallowed to protect main path. ' +
+                        'Fix the hook to prevent silent observability loss.', err);
+                }
+            });
+        }
+    }
+    catch (err) {
+        if (IS_DEV) {
+            console.warn('Actly: observability hook threw — error swallowed to protect main path. ' +
+                'Fix the hook to prevent silent observability loss.', err);
+        }
+    }
+}

package/dist/utils/sanitize.cjs

@@ -2,12 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sanitizeErrorMessage = sanitizeErrorMessage;
 exports.sanitizeError = sanitizeError;
+const limits_js_1 = require("./limits.js");
+const errors_js_1 = require("../errors.js");
 const FORBIDDEN_CHARS = /[\x00-\x1f\x7f]/g;
 const HTML_ENTITIES = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#x27;' };
 function sanitizeErrorMessage(msg) {
     let str;
     if (msg instanceof Error) {
-        str = msg.message;
+        str = String(msg.message ?? '');
     }
     else if (typeof msg === 'string') {
         str = msg;
@@ -17,12 +19,31 @@ function sanitizeErrorMessage(msg) {
     }
     str = str.replace(/[&<>"']/g, (c) => HTML_ENTITIES[c]);
     str = str.replace(FORBIDDEN_CHARS, '');
+    if (str.length > limits_js_1.LIMITS.MAX_SANITIZED_ERROR_LENGTH) {
+        str = str.slice(0, limits_js_1.LIMITS.MAX_SANITIZED_ERROR_LENGTH - 3) + '...';
+    }
     return str;
 }
 function sanitizeError(err) {
     if (err instanceof Error) {
         const sanitized = new Error(sanitizeErrorMessage(err.message));
         sanitized.name = err.name;
+        try {
+            sanitized.stack = err.stack;
+        }
+        catch { }
+        if (err instanceof errors_js_1.ActlyError) {
+            const code = err.code;
+            const key = err.key;
+            Object.defineProperty(sanitized, 'code', { value: code, enumerable: true });
+            if (key !== undefined) {
+                Object.defineProperty(sanitized, 'key', { value: key, enumerable: true });
+            }
+        }
+        try {
+            Object.defineProperty(sanitized, 'cause', { value: err, enumerable: false });
+        }
+        catch { }
         return sanitized;
     }
     return sanitizeErrorMessage(err);

package/dist/utils/sanitize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/utils/sanitize.ts"],"names":[],"mappings":"AAGA,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAYzD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAOnD"}
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/utils/sanitize.ts"],"names":[],"mappings":"AAQA,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAkBzD;AAQD,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAmBnD"}

package/dist/utils/sanitize.js

@@ -1,9 +1,11 @@
+import { LIMITS } from './limits.js';
+import { ActlyError } from '../errors.js';
 const FORBIDDEN_CHARS = /[\x00-\x1f\x7f]/g;
 const HTML_ENTITIES = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#x27;' };
 export function sanitizeErrorMessage(msg) {
     let str;
     if (msg instanceof Error) {
-        str = msg.message;
+        str = String(msg.message ?? '');
     }
     else if (typeof msg === 'string') {
         str = msg;
@@ -13,14 +15,32 @@ export function sanitizeErrorMessage(msg) {
     }
     str = str.replace(/[&<>"']/g, (c) => HTML_ENTITIES[c]);
     str = str.replace(FORBIDDEN_CHARS, '');
+    if (str.length > LIMITS.MAX_SANITIZED_ERROR_LENGTH) {
+        str = str.slice(0, LIMITS.MAX_SANITIZED_ERROR_LENGTH - 3) + '...';
+    }
     return str;
 }
 export function sanitizeError(err) {
     if (err instanceof Error) {
         const sanitized = new Error(sanitizeErrorMessage(err.message));
         sanitized.name = err.name;
+        try {
+            sanitized.stack = err.stack;
+        }
+        catch { }
+        if (err instanceof ActlyError) {
+            const code = err.code;
+            const key = err.key;
+            Object.defineProperty(sanitized, 'code', { value: code, enumerable: true });
+            if (key !== undefined) {
+                Object.defineProperty(sanitized, 'key', { value: key, enumerable: true });
+            }
+        }
+        try {
+            Object.defineProperty(sanitized, 'cause', { value: err, enumerable: false });
+        }
+        catch { }
         return sanitized;
     }
     return sanitizeErrorMessage(err);
 }
-//# sourceMappingURL=sanitize.js.map