@hkdigital/lib-core 0.4.21 → 0.4.23

package/dist/auth/jwt/util.js

@@ -2,24 +2,32 @@
  * JWT utility functions
  *
  * @description
- * This module provides utility functions for JWT operations including 
+ * This module provides utility functions for JWT operations including
  * sign, verify and error casting.
  */
 
+// import jwt from 'jsonwebtoken';
+
+// import {
+//   TokenExpiredError as JwtTokenExpiredError,
+//   JsonWebTokenError as JwtJsonWebTokenError,
+//   NotBeforeError as JwtNotBeforeError
+// } from 'jsonwebtoken';
+
 import jwt from 'jsonwebtoken';
 
-import {
-  TokenExpiredError as JwtTokenExpiredError,
-  JsonWebTokenError as JwtJsonWebTokenError,
-  NotBeforeError as JwtNotBeforeError
-} from 'jsonwebtoken';
+const {
+  TokenExpiredError: JwtTokenExpiredError,
+  JsonWebTokenError: JwtJsonWebTokenError,
+  NotBeforeError: JwtNotBeforeError
+} = jwt;
 
 import * as expect from '../../util/expect.js';
 
 import {
   JWT_DEFAULT_EXPIRES_IN,
   DEFAULT_ALGORITHM,
-  VERIFY_OPTIONS 
+  VERIFY_OPTIONS
 } from './constants.js';
 
 import {
@@ -54,38 +62,28 @@ import {
  *
  * @returns {string} JsonWebToken
  */
-export function sign(
-  claims,
-  secretOrPrivateKey,
-  options={} )
-{
-  expect.object( claims );
-  expect.defined( secretOrPrivateKey );
-
-  if( options )
-  {
-    expect.object( options );
-  }
-  else {
+export function sign(claims, secretOrPrivateKey, options = {}) {
+  expect.object(claims);
+  expect.defined(secretOrPrivateKey);
+
+  if (options) {
+    expect.object(options);
+  } else {
     options = {};
   }
 
-  if( !('algorithm' in options) )
-  {
+  if (!('algorithm' in options)) {
     options.algorithm = DEFAULT_ALGORITHM;
   }
 
-  if( !('expiresIn' in options) )
-  {
+  if (!('expiresIn' in options)) {
     options.expiresIn = JWT_DEFAULT_EXPIRES_IN;
-  }
-  else if( !options.expiresIn )
-  {
+  } else if (!options.expiresIn) {
     delete options.expiresIn;
   }
 
   // @ts-ignore
-  return jwt.sign( claims, secretOrPrivateKey, options );
+  return jwt.sign(claims, secretOrPrivateKey, options);
 }
 
 /**
@@ -99,24 +97,20 @@ export function sign(
  *
  * @returns {import('./typedef.js').JwtPayload} claims - The decoded JWT payload
  */
-export function verify( token, secretOrPrivateKey, options=VERIFY_OPTIONS )
-{
-  expect.notEmptyString( token );
-  expect.defined( secretOrPrivateKey );
+export function verify(token, secretOrPrivateKey, options = VERIFY_OPTIONS) {
+  expect.notEmptyString(token);
+  expect.defined(secretOrPrivateKey);
 
-  if( !('algorithms' in options) )
-  {
+  if (!('algorithms' in options)) {
     options.algorithms = VERIFY_OPTIONS.algorithms;
   }
 
   try {
     // @ts-ignore
-    const decoded = jwt.verify( token, secretOrPrivateKey, options );
+    const decoded = jwt.verify(token, secretOrPrivateKey, options);
 
     return decoded;
-  }
-  catch( e )
-  {
+  } catch (e) {
     //
     // Cast internal jsonwebtoken errors to Error types defined in this lib
     //
@@ -135,18 +129,18 @@ export function castJwtError(error) {
   if (error instanceof JwtTokenExpiredError) {
     return new TokenExpiredError(error.message, error.expiredAt, error);
   }
-  
+
   if (error instanceof JwtNotBeforeError) {
     return new NotBeforeError(error.message, error.date, error);
   }
-  
+
   if (error instanceof JwtJsonWebTokenError) {
     if (error.message === 'invalid signature') {
       return new InvalidSignatureError(error.message, error, error);
     }
     return new JsonWebTokenError(error.message, error, error);
   }
-  
+
   // Return original error if not a known JWT error
   return error;
 }

package/dist/logging/internal/adapters/console.js

@@ -262,7 +262,7 @@ export class ConsoleAdapter {
     let current = err;
     let isFirst = true;
 
-    while (current) {
+    while (current && current instanceof Error) {
       // Check if this is the first error and it's a LoggerError - extract logging context
       if (isFirst && current.name === 'LoggerError') {
         if (current.stack) {
@@ -393,6 +393,12 @@ export class ConsoleAdapter {
         continue;
       }
 
+      // Skip internal logger methods
+      if (cleaned.includes('#toError@') || 
+          (cleaned.includes('logger/Logger.js') && cleaned.includes('#toError'))) {
+        continue;
+      }
+
       relevantFrames.push(cleaned);
 
       // Limit to first 15 relevant frames to see more

package/dist/logging/internal/adapters/formatting.d.ts

@@ -1,9 +1,3 @@
-/**
- * Shared error formatting logic for logging adapters
- *
- * This module contains reusable functions for analyzing and formatting
- * errors with enhanced stack trace detection and error type identification.
- */
 /**
  * Find the most relevant frame index for highlighting in stack traces
  *
@@ -50,9 +44,10 @@ export function getHttpMethod(cleanedStack: string[]): string | null;
  *
  * @param {Error} error - The error object
  * @param {string[]} cleanedStack - Array of cleaned stack trace frames
+ * @param {number} [relevantFrameIndex] - Pre-computed relevant frame index to use
  * @returns {string|null} User function name or null
  */
-export function extractUserFunctionName(error: Error, cleanedStack: string[]): string | null;
+export function extractUserFunctionName(error: Error, cleanedStack: string[], relevantFrameIndex?: number): string | null;
 /**
  * Check if function name is meaningful (not anonymous or framework code)
  *

package/dist/logging/internal/adapters/formatting.js

@@ -1,22 +1,43 @@
 /**
  * Shared error formatting logic for logging adapters
- * 
+ *
  * This module contains reusable functions for analyzing and formatting
  * errors with enhanced stack trace detection and error type identification.
  */
 
+import * as is from '../../../util/is.js';
+
 /**
  * Find the most relevant frame index for highlighting in stack traces
- * 
+ *
  * @param {Error} error - The error object
  * @param {string[]} cleanedStack - Array of cleaned stack trace frames
  * @returns {number} Index of the most relevant frame to highlight
  */
 export function findRelevantFrameIndex(error, cleanedStack) {
+  // Check for SvelteKit HttpError - look for action pattern
+  if (
+    error.name === 'HttpError' &&
+    error.cause &&
+    is.SveltekitHttpError(error.cause)
+  ) {
+    const svelteKitActionsIndex = cleanedStack.findIndex((frame) =>
+      frame.includes(
+        'node_modules/@sveltejs/kit/src/runtime/server/page/actions.js'
+      )
+    );
+    if (svelteKitActionsIndex >= 1) {
+      // Return the frame before the SvelteKit actions.js frame
+      // This should be the actual server action function where throw error() was called
+      return svelteKitActionsIndex - 1;
+    }
+  }
+
   // Check if this is a LoggerError - look for Logger.error call
   if (error.name === 'LoggerError') {
-    const loggerErrorIndex = cleanedStack.findIndex(frame => 
-      frame.includes('Logger.error') && frame.includes('logger/Logger.js')
+    const loggerErrorIndex = cleanedStack.findIndex(
+      (frame) =>
+        frame.includes('Logger.error') && frame.includes('logger/Logger.js')
     );
     if (loggerErrorIndex >= 0 && loggerErrorIndex + 1 < cleanedStack.length) {
       return loggerErrorIndex + 1;
@@ -25,15 +46,17 @@ export function findRelevantFrameIndex(error, cleanedStack) {
 
   if (error.name === 'ValiError') {
     // Look for expect_ function first, user code is right after (handle Node.js format)
-    const expectIndex = cleanedStack.findIndex(frame => 
-      frame.includes('expect_') || frame.includes('Module.expect_')
+    const expectIndex = cleanedStack.findIndex(
+      (frame) => frame.includes('expect_') || frame.includes('Module.expect_')
     );
     if (expectIndex >= 0 && expectIndex + 1 < cleanedStack.length) {
       return expectIndex + 1;
     }
-    
+
     // If no expect_ function, look for valibotParser, user code is right after
-    const valibotIndex = cleanedStack.findIndex(frame => frame.includes('valibotParser'));
+    const valibotIndex = cleanedStack.findIndex((frame) =>
+      frame.includes('valibotParser')
+    );
     if (valibotIndex >= 0 && valibotIndex + 1 < cleanedStack.length) {
       return valibotIndex + 1;
     }
@@ -42,17 +65,19 @@ export function findRelevantFrameIndex(error, cleanedStack) {
   if (error.name === 'DetailedError') {
     // Check if this DetailedError was created by Logger.error - look for Logger.error call first
     // Handle both Firefox format (error@file) and Node.js format (at Logger.error (file))
-    const loggerErrorIndex = cleanedStack.findIndex(frame => 
-      (frame.includes('Logger.error') && frame.includes('logger/Logger.js')) ||
-      (frame.includes('error@') && frame.includes('logger/Logger.js'))
+    const loggerErrorIndex = cleanedStack.findIndex(
+      (frame) =>
+        (frame.includes('Logger.error') &&
+          frame.includes('logger/Logger.js')) ||
+        (frame.includes('error@') && frame.includes('logger/Logger.js'))
     );
     if (loggerErrorIndex >= 0 && loggerErrorIndex + 1 < cleanedStack.length) {
       return loggerErrorIndex + 1;
     }
-    
+
     // Look for rethrow, user code is right after (handle both Firefox and Node.js format)
-    const rethrowIndex = cleanedStack.findIndex(frame => 
-      frame.includes('rethrow@') || frame.includes('at rethrow (')
+    const rethrowIndex = cleanedStack.findIndex(
+      (frame) => frame.includes('rethrow@') || frame.includes('at rethrow (')
     );
     if (rethrowIndex >= 0 && rethrowIndex + 1 < cleanedStack.length) {
       return rethrowIndex + 1;
@@ -61,12 +86,13 @@ export function findRelevantFrameIndex(error, cleanedStack) {
 
   if (error.name === 'PromiseError') {
     // Look for HkPromise methods, user code is right after
-    const hkPromiseIndex = cleanedStack.findIndex(frame => 
-      frame.includes('reject@') || 
-      frame.includes('tryReject@') || 
-      frame.includes('setTimeout@') || 
-      frame.includes('cancel@') || 
-      frame.includes('tryCancel@')
+    const hkPromiseIndex = cleanedStack.findIndex(
+      (frame) =>
+        frame.includes('reject@') ||
+        frame.includes('tryReject@') ||
+        frame.includes('setTimeout@') ||
+        frame.includes('cancel@') ||
+        frame.includes('tryCancel@')
     );
     if (hkPromiseIndex >= 0 && hkPromiseIndex + 1 < cleanedStack.length) {
       return hkPromiseIndex + 1;
@@ -92,14 +118,18 @@ export function findRelevantFrameIndex(error, cleanedStack) {
 
 /**
  * Detect error metadata for structured logging and display
- * 
+ *
  * @param {Error} error - The error object
  * @param {string[]} cleanedStack - Array of cleaned stack trace frames
  * @returns {import('./typedef.js').ErrorSummaryMeta} Error metadata
  */
 export function detectErrorMeta(error, cleanedStack) {
-  const userFunctionName = extractUserFunctionName(error, cleanedStack);
   const relevantFrameIndex = findRelevantFrameIndex(error, cleanedStack);
+  const userFunctionName = extractUserFunctionName(
+    error,
+    cleanedStack,
+    relevantFrameIndex
+  );
 
   // Check if it's a LoggerError
   if (error.name === 'LoggerError') {
@@ -115,11 +145,13 @@ export function detectErrorMeta(error, cleanedStack) {
   if (error.name === 'DetailedError') {
     // Check if this DetailedError was created by Logger.error
     const cleanedStackArray = cleanedStack || [];
-    const loggerErrorIndex = cleanedStackArray.findIndex(frame => 
-      (frame.includes('Logger.error') && frame.includes('logger/Logger.js')) ||
-      (frame.includes('error@') && frame.includes('logger/Logger.js'))
+    const loggerErrorIndex = cleanedStackArray.findIndex(
+      (frame) =>
+        (frame.includes('Logger.error') &&
+          frame.includes('logger/Logger.js')) ||
+        (frame.includes('error@') && frame.includes('logger/Logger.js'))
     );
-    
+
     if (loggerErrorIndex >= 0) {
       return {
         category: 'logger',
@@ -128,7 +160,7 @@ export function detectErrorMeta(error, cleanedStack) {
         relevantFrameIndex
       };
     }
-    
+
     // Otherwise it's a regular rethrow error
     return {
       category: 'rethrow',
@@ -163,15 +195,15 @@ export function detectErrorMeta(error, cleanedStack) {
   // Check if it's a valibot validation error
   if (error.name === 'ValiError' && cleanedStack.length > 0) {
     // Look for our valibotParser wrapper function in the stack
-    const valibotFrame = cleanedStack.find(frame => 
+    const valibotFrame = cleanedStack.find((frame) =>
       frame.includes('valibotParser')
     );
-    
+
     // Also check if it's called via an expect_ function (handle Node.js format)
-    const expectFrame = cleanedStack.find(frame => 
-      frame.includes('expect_') || frame.includes('Module.expect_')
+    const expectFrame = cleanedStack.find(
+      (frame) => frame.includes('expect_') || frame.includes('Module.expect_')
     );
-    
+
     if (valibotFrame || expectFrame) {
       return {
         category: 'validation',
@@ -193,7 +225,7 @@ export function detectErrorMeta(error, cleanedStack) {
 
 /**
  * Format error metadata for console display
- * 
+ *
  * @param {{category: string, method: string, origin?: string|null}} errorMeta - Error metadata
  * @returns {string} Formatted display string (e.g., "httpGet in myFunction")
  */
@@ -206,43 +238,44 @@ export function formatErrorDisplay(errorMeta) {
 
 /**
  * Get the specific HkPromise method that caused the error
- * 
+ *
  * @param {string[]} cleanedStack - Array of cleaned stack trace frames
  * @returns {string|null} HkPromise method name or null
  */
 export function getHkPromiseMethod(cleanedStack) {
-  const hkPromiseFrame = cleanedStack.find(frame => 
-    frame.includes('reject@') || 
-    frame.includes('tryReject@') || 
-    frame.includes('setTimeout@') || 
-    frame.includes('cancel@') || 
-    frame.includes('tryCancel@')
+  const hkPromiseFrame = cleanedStack.find(
+    (frame) =>
+      frame.includes('reject@') ||
+      frame.includes('tryReject@') ||
+      frame.includes('setTimeout@') ||
+      frame.includes('cancel@') ||
+      frame.includes('tryCancel@')
   );
-  
+
   if (!hkPromiseFrame) return null;
-  
+
   if (hkPromiseFrame.includes('reject@')) return 'reject';
   if (hkPromiseFrame.includes('tryReject@')) return 'tryReject';
   if (hkPromiseFrame.includes('setTimeout@')) return 'setTimeout';
   if (hkPromiseFrame.includes('cancel@')) return 'cancel';
   if (hkPromiseFrame.includes('tryCancel@')) return 'tryCancel';
-  
+
   return null;
 }
 
 /**
  * Get the specific HTTP method that caused the error
- * 
+ *
  * @param {string[]} cleanedStack - Array of cleaned stack trace frames
  * @returns {string|null} HTTP method name or null
  */
 export function getHttpMethod(cleanedStack) {
-  const httpFrame = cleanedStack.find(frame => 
+  const httpFrame = cleanedStack.find((frame) =>
     frame.includes('network/http/http-request.js')
   );
-  
+
   if (!httpFrame) return null;
-  
+
   if (httpFrame.includes('httpGet@')) return 'httpGet';
   if (httpFrame.includes('httpPost@')) return 'httpPost';
   if (httpFrame.includes('httpPut@')) return 'httpPut';
@@ -250,22 +283,32 @@ export function getHttpMethod(cleanedStack) {
   if (httpFrame.includes('httpPatch@')) return 'httpPatch';
   if (httpFrame.includes('httpOptions@')) return 'httpOptions';
   if (httpFrame.includes('httpRequest@')) return 'httpRequest';
-  
+
   return null;
 }
 
 /**
  * Extract user function name from stack trace
- * 
+ *
  * @param {Error} error - The error object
  * @param {string[]} cleanedStack - Array of cleaned stack trace frames
+ * @param {number} [relevantFrameIndex] - Pre-computed relevant frame index to use
  * @returns {string|null} User function name or null
  */
-export function extractUserFunctionName(error, cleanedStack) {
+export function extractUserFunctionName(
+  error,
+  cleanedStack,
+  relevantFrameIndex
+) {
+  // If we have a pre-computed relevant frame index, use it
+  if (relevantFrameIndex >= 0 && relevantFrameIndex < cleanedStack.length) {
+    return parseFunctionName(cleanedStack[relevantFrameIndex]);
+  }
   // Check if this is a LoggerError - look for the frame after Logger.error
   if (error.name === 'LoggerError' && cleanedStack.length > 1) {
-    const loggerErrorIndex = cleanedStack.findIndex(frame => 
-      frame.includes('Logger.error') && frame.includes('logger/Logger.js')
+    const loggerErrorIndex = cleanedStack.findIndex(
+      (frame) =>
+        frame.includes('Logger.error') && frame.includes('logger/Logger.js')
     );
     if (loggerErrorIndex >= 0 && loggerErrorIndex + 1 < cleanedStack.length) {
       return parseFunctionName(cleanedStack[loggerErrorIndex + 1]);
@@ -274,17 +317,19 @@ export function extractUserFunctionName(error, cleanedStack) {
 
   if (error.name === 'DetailedError' && cleanedStack.length > 1) {
     // Check if this DetailedError was created by Logger.error - look for the frame after Logger.error
-    const loggerErrorIndex = cleanedStack.findIndex(frame => 
-      (frame.includes('Logger.error') && frame.includes('logger/Logger.js')) ||
-      (frame.includes('error@') && frame.includes('logger/Logger.js'))
+    const loggerErrorIndex = cleanedStack.findIndex(
+      (frame) =>
+        (frame.includes('Logger.error') &&
+          frame.includes('logger/Logger.js')) ||
+        (frame.includes('error@') && frame.includes('logger/Logger.js'))
     );
     if (loggerErrorIndex >= 0 && loggerErrorIndex + 1 < cleanedStack.length) {
       return parseFunctionName(cleanedStack[loggerErrorIndex + 1]);
     }
-    
+
     // For rethrow errors, look for the frame after rethrow (handle both formats)
-    const rethrowIndex = cleanedStack.findIndex(frame => 
-      frame.includes('rethrow@') || frame.includes('at rethrow (')
+    const rethrowIndex = cleanedStack.findIndex(
+      (frame) => frame.includes('rethrow@') || frame.includes('at rethrow (')
     );
     if (rethrowIndex >= 0 && rethrowIndex + 1 < cleanedStack.length) {
       return parseFunctionName(cleanedStack[rethrowIndex + 1]);
@@ -293,12 +338,13 @@ export function extractUserFunctionName(error, cleanedStack) {
 
   if (error.name === 'PromiseError' && cleanedStack.length > 1) {
     // For PromiseError, look for the frame after HkPromise methods
-    const hkPromiseIndex = cleanedStack.findIndex(frame => 
-      frame.includes('reject@') || 
-      frame.includes('tryReject@') || 
-      frame.includes('setTimeout@') || 
-      frame.includes('cancel@') || 
-      frame.includes('tryCancel@')
+    const hkPromiseIndex = cleanedStack.findIndex(
+      (frame) =>
+        frame.includes('reject@') ||
+        frame.includes('tryReject@') ||
+        frame.includes('setTimeout@') ||
+        frame.includes('cancel@') ||
+        frame.includes('tryCancel@')
     );
     if (hkPromiseIndex >= 0 && hkPromiseIndex + 1 < cleanedStack.length) {
       return parseFunctionName(cleanedStack[hkPromiseIndex + 1]);
@@ -320,15 +366,17 @@ export function extractUserFunctionName(error, cleanedStack) {
 
   if (error.name === 'ValiError' && cleanedStack.length > 1) {
     // For validation errors, look for the frame after expect_ function first (handle Node.js format)
-    const expectIndex = cleanedStack.findIndex(frame => 
-      frame.includes('expect_') || frame.includes('Module.expect_')
+    const expectIndex = cleanedStack.findIndex(
+      (frame) => frame.includes('expect_') || frame.includes('Module.expect_')
     );
     if (expectIndex >= 0 && expectIndex + 1 < cleanedStack.length) {
       return parseFunctionName(cleanedStack[expectIndex + 1]);
     }
-    
+
     // If no expect_ function, look for valibotParser wrapper
-    const valibotIndex = cleanedStack.findIndex(frame => frame.includes('valibotParser'));
+    const valibotIndex = cleanedStack.findIndex((frame) =>
+      frame.includes('valibotParser')
+    );
     if (valibotIndex >= 0 && valibotIndex + 1 < cleanedStack.length) {
       return parseFunctionName(cleanedStack[valibotIndex + 1]);
     }
@@ -347,49 +395,51 @@ export function extractUserFunctionName(error, cleanedStack) {
 
 /**
  * Check if function name is meaningful (not anonymous or framework code)
- * 
+ *
  * @param {string} functionName - Function name to check
  * @returns {boolean} True if the function name is meaningful
  */
 export function isMeaningfulFunctionName(functionName) {
   // Skip empty names, anonymous functions, and framework/internal functions
-  if (!functionName || 
-      functionName === '' || 
-      functionName.includes('<') || 
-      functionName.includes('/') ||
-      functionName.startsWith('async ') ||
-      functionName === 'async' ||
-      functionName === 'Promise' ||
-      functionName === 'new Promise' ||
-      functionName.includes('internal') ||
-      functionName.includes('node_modules')) {
+  if (
+    !functionName ||
+    functionName === '' ||
+    functionName.includes('<') ||
+    functionName.includes('/') ||
+    functionName.startsWith('async ') ||
+    functionName === 'async' ||
+    functionName === 'Promise' ||
+    functionName === 'new Promise' ||
+    functionName.includes('internal') ||
+    functionName.includes('node_modules')
+  ) {
     return false;
   }
-  
+
   return true;
 }
 
 /**
  * Parse function name from stack frame
- * 
+ *
  * @param {string} frame - Stack trace frame
  * @returns {string|null} Function name or null
  */
 export function parseFunctionName(frame) {
   // Handle both Firefox format: "functionName@file:line:col"
   // and Node.js format: "at functionName (file:line:col)" or "at Module.functionName (file:line:col)"
-  
+
   // Firefox format
   const firefoxMatch = frame.match(/^([^@]+)@/);
   if (firefoxMatch) {
     return firefoxMatch[1];
   }
-  
+
   // Node.js format
   const nodeMatch = frame.match(/^\s*at\s+(?:Module\.)?([^\s(]+)/);
   if (nodeMatch) {
     return nodeMatch[1];
   }
-  
+
   return null;
-}
+}

package/dist/logging/internal/adapters/pino.js

@@ -209,9 +209,12 @@ export class PinoAdapter {
     const pnpmRegex2 = /node_modules\/\.pnpm\/[^/]+\/node_modules\/([^/]+)/g;
     cleaned = cleaned.replace(pnpmRegex2, 'node_modules/$1');
 
-    // Filter out Node.js internal modules
+    // Filter out Node.js internal modules and internal logger methods
     const lines = cleaned.split('\n');
-    const filteredLines = lines.filter(line => !line.includes('node:internal'));
+    const filteredLines = lines.filter(line => 
+      !line.includes('node:internal') &&
+      !(line.includes('#toError') && line.includes('logger/Logger.js'))
+    );
     cleaned = filteredLines.join('\n');
 
     return cleaned;

package/dist/logging/internal/logger/Logger.js

@@ -57,6 +57,7 @@ import { exportNotNullish } from '../../../util/object.js';
 // } from './util.js';
 
 import * as is from '../../../util/is.js';
+import { HttpError } from '../../../network/errors.js';
 
 /**
  * Logger class for consistent logging
@@ -308,7 +309,8 @@ export default class Logger extends EventEmitter {
     return (
       thing instanceof Error ||
       is.ErrorEvent(thing) ||
-      is.PromiseRejectionEvent(thing)
+      is.PromiseRejectionEvent(thing) ||
+      is.SveltekitHttpError(thing)
     );
   }
 
@@ -365,6 +367,18 @@ export default class Logger extends EventEmitter {
         // reason is not an Error or string
         return new DetailedError('Promise rejected', reason);
       }
+    } else if (is.SveltekitHttpError(errorLike)) {
+      // errorLike is a SvelteKit HttpError
+      // => convert to lib's HttpError for consistent error handling
+      const svelteKitError = errorLike;
+
+      return new HttpError(
+        svelteKitError.status,
+        svelteKitError.body?.message || 'SvelteKit HttpError',
+        exportNotNullish(svelteKitError),
+        svelteKitError  // Set original SvelteKit error as cause
+      );
+
     } else if (errorLike instanceof Error) {
       // errorLike is a plain Error
       // => return it

package/dist/logging/internal/test-errors.d.ts

@@ -33,3 +33,7 @@ export function throwRethrowChainError(): void;
  * Raw valibot validation error (without expect wrapper)
  */
 export function throwRawValibotError(): any;
+/**
+ * SvelteKit error that goes through handleError hook
+ */
+export function throwSvelteKitError(): void;

package/dist/logging/internal/test-errors.js

@@ -3,6 +3,7 @@ import { rethrow } from '../../util/exceptions.js';
 import { HkPromise } from '../../generic/promises.js';
 import { httpGet } from '../../network/http/index.js';
 import { v } from '../../valibot/valibot.js';
+import { error } from '@sveltejs/kit';
 
 /**
  * Test functions for generating various types of errors for logging demonstration
@@ -137,3 +138,10 @@ export function throwRawValibotError() {
   // This will throw a ValiError directly from our valibotParser wrapper
   return v.parse(schema, invalidValue);
 }
+
+/**
+ * SvelteKit error that goes through handleError hook
+ */
+export function throwSvelteKitError() {
+  throw error(500, 'SvelteKit error test - this goes through handleError');
+}

package/dist/util/is/sveltekit.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if object is a SvelteKit HttpError
+ *
+ * @param {any} thing
+ *
+ * @returns {boolean}
+ */
+export function SveltekitHttpError(thing: any): boolean;

package/dist/util/is/sveltekit.js

@@ -0,0 +1,14 @@
+/**
+ * Check if object is a SvelteKit HttpError
+ *
+ * @param {any} thing
+ *
+ * @returns {boolean}
+ */
+export function SveltekitHttpError(thing) {
+  return Boolean(
+    thing instanceof Object &&
+      thing.constructor?.name === 'HttpError' &&
+      'status' in thing
+  );
+}

package/dist/util/is.d.ts

@@ -1 +1,3 @@
+export * from "./is/events.js";
 export * from "./is/index.js";
+export * from "./is/sveltekit.js";

package/dist/util/is.js

@@ -5,4 +5,6 @@
  * This module provides type checking and validation utilities.
  */
 
-export * from './is/index.js';
+export * from './is/events.js';
+export * from './is/index.js';
+export * from './is/sveltekit.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-core",
-	"version": "0.4.21",
+	"version": "0.4.23",
 	"author": {
 		"name": "HKdigital",
 		"url": "https://hkdigital.nl"