@visulima/error 6.0.0-alpha.2 → 6.0.0-alpha.4

package/CHANGELOG.md

@@ -1,3 +1,32 @@
+## @visulima/error [6.0.0-alpha.4](https://github.com/visulima/visulima/compare/@visulima/error@6.0.0-alpha.3...@visulima/error@6.0.0-alpha.4) (2026-01-17)
+
+### ⚠ BREAKING CHANGES
+
+* **serialize:** Serialized errors now have all properties explicitly enumerable, which may affect code relying on property enumerability checks. ErrorProto properties are now non-enumerable.
+
+### Bug Fixes
+
+* **serialize:** improve error serialization enumerability and circular reference handling ([41e2f0b](https://github.com/visulima/visulima/commit/41e2f0b2dd43b75ec4c44dda0bad3200319cd489))
+
+### Miscellaneous Chores
+
+* **error:** update dependencies ([8dcc42c](https://github.com/visulima/visulima/commit/8dcc42cc1cbe6f3acceecb3360cb8dce0b99deb7))
+
+## @visulima/error [6.0.0-alpha.3](https://github.com/visulima/visulima/compare/@visulima/error@6.0.0-alpha.2...@visulima/error@6.0.0-alpha.3) (2025-12-27)
+
+### Bug Fixes
+
+* **error:** update package files ([ea9d556](https://github.com/visulima/visulima/commit/ea9d55669d1f3e0d7902d931a82e0acd39081ea7))
+
+### Miscellaneous Chores
+
+* fixed project.json names and schema path ([964722f](https://github.com/visulima/visulima/commit/964722f691db205c7edb9aa6db29e849a647500b))
+
+
+### Dependencies
+
+* **@visulima/path:** upgraded to 3.0.0-alpha.4
+
 ## @visulima/error [6.0.0-alpha.2](https://github.com/visulima/visulima/compare/@visulima/error@6.0.0-alpha.1...@visulima/error@6.0.0-alpha.2) (2025-12-11)
 
 ### Bug Fixes

package/dist/error/index.js

@@ -1,8 +1,8 @@
 export { default as captureRawStackTrace } from '../packem_shared/captureRawStackTrace-ySw7cU0U.js';
 export { default as getErrorCauses } from '../packem_shared/getErrorCauses-DpUsmuqw.js';
 export { renderError } from '../packem_shared/renderError-C30PRFtU.js';
-export { default as deserializeError } from '../packem_shared/deserializeError-CvSvGfXa.js';
+export { default as deserializeError } from '../packem_shared/deserializeError-BsFrjsrV.js';
 export { addKnownErrorConstructor, isErrorLike } from '../packem_shared/addKnownErrorConstructor-s_3SsXtQ.js';
 export { default as NonError } from '../packem_shared/NonError-D5FGLYKY.js';
-export { serialize as serializeError } from '../packem_shared/serializeError-BZ62KiYZ.js';
+export { serialize as serializeError } from '../packem_shared/serializeError-e9YW13-X.js';
 export { VisulimaError, isVisulimaError } from '../packem_shared/isVisulimaError-DA7QsCxH.js';

package/dist/index.js

@@ -5,12 +5,12 @@ export { default as aiSolutionResponse } from './packem_shared/aiSolutionRespons
 export { default as errorHintFinder } from './packem_shared/errorHintFinder-DEaeRnRW.js';
 export { default as ruleBasedFinder } from './packem_shared/ruleBasedFinder-C2F8rQ30.js';
 export { default as captureRawStackTrace } from './packem_shared/captureRawStackTrace-ySw7cU0U.js';
-export { default as deserializeError } from './packem_shared/deserializeError-CvSvGfXa.js';
+export { default as deserializeError } from './packem_shared/deserializeError-BsFrjsrV.js';
 export { default as getErrorCauses } from './packem_shared/getErrorCauses-DpUsmuqw.js';
 export { default as NonError } from './packem_shared/NonError-D5FGLYKY.js';
 export { default as parseStacktrace } from './packem_shared/parseStacktrace-oQvk7wYp.js';
 export { addKnownErrorConstructor, isErrorLike } from './packem_shared/addKnownErrorConstructor-s_3SsXtQ.js';
 export { VisulimaError, isVisulimaError } from './packem_shared/isVisulimaError-DA7QsCxH.js';
 export { renderError } from './packem_shared/renderError-C30PRFtU.js';
-export { serialize as serializeError } from './packem_shared/serializeError-BZ62KiYZ.js';
+export { serialize as serializeError } from './packem_shared/serializeError-e9YW13-X.js';
 export { formatStackFrameLine, formatStacktrace } from './packem_shared/formatStackFrameLine-D3_6oSWZ.js';

package/dist/packem_shared/{deserializeError-CvSvGfXa.js → deserializeError-BsFrjsrV.js}

@@ -43,7 +43,14 @@ const reconstructError = (serialized, options, depth) => {
 };
 const deserializeValue = (value, options, depth) => {
   if (isPlainObject(value)) {
-    return deserializePlainObject(value, options, depth);
+    if (isErrorLike(value)) {
+      return deserializePlainObject(value, options, depth);
+    }
+    const result = {};
+    for (const [key, value_] of Object.entries(value)) {
+      result[key] = deserializeValue(value_, options, depth + 1);
+    }
+    return result;
   }
   if (Array.isArray(value)) {
     return value.map((item) => deserializeValue(item, options, depth));

package/dist/packem_shared/serializeError-e9YW13-X.js

@@ -0,0 +1,224 @@
+import { i as isPlainObject } from './index-y_UPkY2Z.js';
+
+const ErrorProto = Object.create(
+  {},
+  {
+    cause: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    },
+    code: {
+      enumerable: true,
+      value: void 0,
+      writable: true
+    },
+    errors: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    },
+    message: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    },
+    name: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    },
+    stack: {
+      enumerable: false,
+      value: void 0,
+      writable: true
+    }
+  }
+);
+
+const toJsonWasCalled = /* @__PURE__ */ new WeakSet();
+const makePropertiesEnumerable = (object) => {
+  if (!object || typeof object !== "object") {
+    return;
+  }
+  const props = Object.getOwnPropertyNames(object);
+  for (const prop of props) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, prop);
+    if (descriptor) {
+      if (!descriptor.enumerable) {
+        Object.defineProperty(object, prop, {
+          ...descriptor,
+          enumerable: true
+        });
+      }
+      if (descriptor.value && typeof descriptor.value === "object" && !Array.isArray(descriptor.value) && (Object.getPrototypeOf(descriptor.value) === Object.prototype || Object.getPrototypeOf(descriptor.value) === null)) {
+        makePropertiesEnumerable(descriptor.value);
+      }
+    }
+  }
+};
+const toJSON = (from) => {
+  toJsonWasCalled.add(from);
+  const json = from.toJSON();
+  toJsonWasCalled.delete(from);
+  if (json && typeof json === "object" && Object.isExtensible(json)) {
+    makePropertiesEnumerable(json);
+  }
+  return json;
+};
+const serializeValue = (value, seen, depth, options) => {
+  if (value && value instanceof Uint8Array && value.constructor.name === "Buffer") {
+    return "[object Buffer]";
+  }
+  if (value !== null && typeof value === "object" && typeof value.pipe === "function") {
+    return "[object Stream]";
+  }
+  if (value instanceof Error) {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    depth += 1;
+    return _serialize(value, options, seen, depth);
+  }
+  if (options.useToJSON && typeof value.toJSON === "function") {
+    return value.toJSON();
+  }
+  if (typeof value === "object" && value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "function") {
+    return `[Function: ${value.name || "anonymous"}]`;
+  }
+  if (typeof value === "bigint") {
+    return `${value}n`;
+  }
+  if (isPlainObject(value)) {
+    if (options.maxDepth !== void 0 && options.maxDepth !== Number.POSITIVE_INFINITY && depth + 1 >= options.maxDepth) {
+      return {};
+    }
+    depth += 1;
+    const plainObject = {};
+    for (const key in value) {
+      plainObject[key] = serializeValue(value[key], seen, depth, options);
+    }
+    return plainObject;
+  }
+  try {
+    return value;
+  } catch {
+    return "[Not Available]";
+  }
+};
+const _serialize = (error, options, seen, depth) => {
+  seen.add(error);
+  if (options.maxDepth === 0) {
+    return {};
+  }
+  if (options.useToJSON && typeof error.toJSON === "function" && !toJsonWasCalled.has(error)) {
+    return toJSON(error);
+  }
+  const protoError = Object.create(ErrorProto);
+  Object.defineProperty(protoError, "name", {
+    configurable: true,
+    enumerable: true,
+    value: Object.prototype.toString.call(error.constructor) === "[object Function]" ? error.constructor.name : error.name,
+    writable: true
+  });
+  Object.defineProperty(protoError, "message", {
+    configurable: true,
+    enumerable: true,
+    value: error.message,
+    writable: true
+  });
+  Object.defineProperty(protoError, "stack", {
+    configurable: true,
+    enumerable: true,
+    value: error.stack,
+    writable: true
+  });
+  if (Array.isArray(error.errors)) {
+    const aggregateErrors = [];
+    for (const aggregateError of error.errors) {
+      if (!(aggregateError instanceof Error)) {
+        throw new TypeError("All errors in the 'errors' property must be instances of Error");
+      }
+      if (seen.has(aggregateError)) {
+        Object.defineProperty(protoError, "errors", {
+          configurable: true,
+          enumerable: true,
+          value: [],
+          writable: true
+        });
+        return protoError;
+      }
+      aggregateErrors.push(_serialize(aggregateError, options, seen, depth));
+    }
+    Object.defineProperty(protoError, "errors", {
+      configurable: true,
+      enumerable: true,
+      value: aggregateErrors,
+      writable: true
+    });
+  }
+  if (error.cause !== void 0 && error.cause !== null) {
+    if (error.cause instanceof Error) {
+      if (seen.has(error.cause)) {
+        Object.defineProperty(protoError, "cause", {
+          configurable: true,
+          enumerable: true,
+          value: "[Circular]",
+          writable: true
+        });
+      } else {
+        Object.defineProperty(protoError, "cause", {
+          configurable: true,
+          enumerable: true,
+          value: _serialize(error.cause, options, seen, depth),
+          writable: true
+        });
+      }
+    } else {
+      const serializedCause = serializeValue(error.cause, seen, depth, options);
+      Object.defineProperty(protoError, "cause", {
+        configurable: true,
+        enumerable: true,
+        value: serializedCause,
+        writable: true
+      });
+    }
+  }
+  for (const key in error) {
+    if (key === "name" || key === "message" || key === "stack" || key === "cause" || key === "errors") {
+      continue;
+    }
+    const value = error[key];
+    const serializedValue = serializeValue(value, seen, depth, options);
+    Object.defineProperty(protoError, key, {
+      configurable: true,
+      enumerable: true,
+      value: serializedValue,
+      writable: true
+    });
+  }
+  if (Array.isArray(options.exclude) && options.exclude.length > 0) {
+    for (const key of options.exclude) {
+      try {
+        delete protoError[key];
+      } catch {
+      }
+    }
+  }
+  return protoError;
+};
+const serialize = (error, options = {}) => _serialize(
+  error,
+  {
+    exclude: options.exclude ?? [],
+    maxDepth: options.maxDepth ?? Number.POSITIVE_INFINITY,
+    useToJSON: options.useToJSON ?? false
+  },
+  /* @__PURE__ */ new Set(),
+  0
+);
+
+export { serialize };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/error",
-  "version": "6.0.0-alpha.2",
+  "version": "6.0.0-alpha.4",
   "description": "Error with more than just a message, stacktrace parsing.",
   "keywords": [
     "anolilab",

package/dist/packem_shared/serializeError-BZ62KiYZ.js

@@ -1,142 +0,0 @@
-import { i as isPlainObject } from './index-y_UPkY2Z.js';
-
-const ErrorProto = Object.create(
-  {},
-  {
-    cause: {
-      enumerable: true,
-      value: void 0,
-      writable: true
-    },
-    code: {
-      enumerable: true,
-      value: void 0,
-      writable: true
-    },
-    errors: {
-      enumerable: true,
-      value: void 0,
-      writable: true
-    },
-    message: {
-      enumerable: true,
-      value: void 0,
-      writable: true
-    },
-    name: {
-      enumerable: true,
-      value: void 0,
-      writable: true
-    },
-    stack: {
-      enumerable: true,
-      value: void 0,
-      writable: true
-    }
-  }
-);
-
-const toJsonWasCalled = /* @__PURE__ */ new WeakSet();
-const toJSON = (from) => {
-  toJsonWasCalled.add(from);
-  const json = from.toJSON();
-  toJsonWasCalled.delete(from);
-  return json;
-};
-const serializeValue = (value, seen, depth, options) => {
-  if (value && value instanceof Uint8Array && value.constructor.name === "Buffer") {
-    return "[object Buffer]";
-  }
-  if (value !== null && typeof value === "object" && typeof value.pipe === "function") {
-    return "[object Stream]";
-  }
-  if (value instanceof Error) {
-    if (seen.includes(value)) {
-      return "[Circular]";
-    }
-    depth += 1;
-    return _serialize(value, options, seen, depth);
-  }
-  if (options.useToJSON && typeof value.toJSON === "function") {
-    return value.toJSON();
-  }
-  if (typeof value === "object" && value instanceof Date) {
-    return value.toISOString();
-  }
-  if (typeof value === "function") {
-    return `[Function: ${value.name || "anonymous"}]`;
-  }
-  if (isPlainObject(value)) {
-    depth += 1;
-    if (options.maxDepth && depth >= options.maxDepth) {
-      return {};
-    }
-    const plainObject = {};
-    for (const key in value) {
-      plainObject[key] = serializeValue(value[key], seen, depth, options);
-    }
-    return plainObject;
-  }
-  try {
-    return value;
-  } catch {
-    return "[Not Available]";
-  }
-};
-const _serialize = (error, options, seen, depth) => {
-  seen.push(error);
-  if (options.maxDepth === 0) {
-    return {};
-  }
-  if (options.useToJSON && typeof error.toJSON === "function" && !toJsonWasCalled.has(error)) {
-    return toJSON(error);
-  }
-  const protoError = Object.create(ErrorProto);
-  protoError.name = Object.prototype.toString.call(error.constructor) === "[object Function]" ? error.constructor.name : error.name;
-  protoError.message = error.message;
-  protoError.stack = error.stack;
-  if (Array.isArray(error.errors)) {
-    const aggregateErrors = [];
-    for (const aggregateError of error.errors) {
-      if (!(aggregateError instanceof Error)) {
-        throw new TypeError("All errors in the 'errors' property must be instances of Error");
-      }
-      if (seen.includes(aggregateError)) {
-        protoError.errors = [];
-        return protoError;
-      }
-      aggregateErrors.push(_serialize(aggregateError, options, seen, depth));
-    }
-    protoError.errors = aggregateErrors;
-  }
-  if (error.cause instanceof Error && !seen.includes(error.cause)) {
-    protoError.cause = _serialize(error.cause, options, seen, depth);
-  }
-  for (const key in error) {
-    if (protoError[key] === void 0) {
-      const value = error[key];
-      protoError[key] = serializeValue(value, seen, depth, options);
-    }
-  }
-  if (Array.isArray(options.exclude) && options.exclude.length > 0) {
-    for (const key of options.exclude) {
-      try {
-        delete protoError[key];
-      } catch {
-      }
-    }
-  }
-  return protoError;
-};
-const serialize = (error, options = {}) => _serialize(
-  error,
-  {
-    exclude: options.exclude ?? [],
-    maxDepth: options.maxDepth ?? Number.POSITIVE_INFINITY,
-    useToJSON: options.useToJSON ?? false
-  },
-  [],
-  0
-);
-
-export { serialize };