@outputai/core 0.8.2-next.013689b.0 → 0.8.2-next.0f9af4b.0

package/src/internal_activities/index.js

@@ -1,10 +1,10 @@
 import { FatalError } from '#errors';
 import { fetch } from 'undici';
-import { serializeFetchResponse, serializeBodyAndInferContentType } from '#utils';
-import { setMetadata } from '#internal_utils/component';
-import { ComponentType } from '#consts';
+import { serializeFetchResponse, serializeBodyAndInferContentType } from '#helpers/fetch';
 import { createChildLogger } from '#logger';
 import { getDestinations } from '#tracing';
+import { createInternalStep } from '#helpers/component';
+import { ACTIVITY_GET_TRACE_DESTINATIONS, ACTIVITY_SEND_HTTP_REQUEST } from '#consts';
 
 const log = createChildLogger( 'HttpClient' );
 
@@ -20,41 +20,42 @@ const log = createChildLogger( 'HttpClient' );
  * @returns {object} The serialized HTTP response
  * @throws {FatalError}
  */
-export const sendHttpRequest = async ( { url, method, payload = undefined, headers = undefined, timeout = 30_000 } ) => {
-  const args = {
-    method,
-    headers: new Headers( headers ?? {} ),
-    signal: AbortSignal.timeout( timeout )
-  };
+export const sendHttpRequest = createInternalStep( {
+  name: ACTIVITY_SEND_HTTP_REQUEST,
+  handler: async ( { url, method, payload = undefined, headers = undefined, timeout = 30_000 } ) => {
+    const args = {
+      method,
+      headers: new Headers( headers ?? {} ),
+      signal: AbortSignal.timeout( timeout )
+    };
 
-  const methodsWithBody = [ 'DELETE', 'PATCH', 'POST', 'PUT', 'OPTIONS' ];
-  const hasBodyPayload = ![ undefined, null ].includes( payload );
-  if ( methodsWithBody.includes( method ) && hasBodyPayload ) {
-    const { body, contentType } = serializeBodyAndInferContentType( payload );
-    if ( contentType && !args.headers.has( 'content-type' ) ) {
-      args.headers.set( 'Content-Type', contentType );
-    }
-    Object.assign( args, { body } );
-  };
-
-  const response = await ( async () => {
-    try {
-      return await fetch( url, args );
-    } catch ( e ) {
-      throw new FatalError( `${method} ${url} ${e.cause ?? e.message}` );
-    }
-  } )();
+    const methodsWithBody = [ 'DELETE', 'PATCH', 'POST', 'PUT', 'OPTIONS' ];
+    const hasBodyPayload = ![ undefined, null ].includes( payload );
+    if ( methodsWithBody.includes( method ) && hasBodyPayload ) {
+      const { body, contentType } = serializeBodyAndInferContentType( payload );
+      if ( contentType && !args.headers.has( 'content-type' ) ) {
+        args.headers.set( 'Content-Type', contentType );
+      }
+      Object.assign( args, { body } );
+    };
 
-  log.info( 'HTTP request completed', { url, method, status: response.status, statusText: response.statusText } );
+    const response = await ( async () => {
+      try {
+        return await fetch( url, args );
+      } catch ( e ) {
+        throw new FatalError( `${method} ${url} ${e.cause ?? e.message}` );
+      }
+    } )();
 
-  if ( !response.ok ) {
-    throw new FatalError( `${method} ${url} ${response.status}` );
-  }
+    log.info( 'HTTP request completed', { url, method, status: response.status, statusText: response.statusText } );
 
-  return serializeFetchResponse( response );
-};
+    if ( !response.ok ) {
+      throw new FatalError( `${method} ${url} ${response.status}` );
+    }
 
-setMetadata( sendHttpRequest, { type: ComponentType.INTERNAL_STEP } );
+    return serializeFetchResponse( response );
+  }
+} );
 
 /**
  * Invokes a trace method that resolves all trace output paths based on the traceInfo
@@ -62,6 +63,7 @@ setMetadata( sendHttpRequest, { type: ComponentType.INTERNAL_STEP } );
  * @param {object} traceInfo
  * @returns {object} Information about enabled destinations
  */
-export const getTraceDestinations = traceInfo => getDestinations( traceInfo );
-
-setMetadata( getTraceDestinations, { type: ComponentType.INTERNAL_STEP } );
+export const getTraceDestinations = createInternalStep( {
+  name: ACTIVITY_GET_TRACE_DESTINATIONS,
+  handler: traceInfo => getDestinations( traceInfo )
+} );

package/src/internal_activities/index.spec.js

@@ -1,10 +1,12 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { MockAgent, setGlobalDispatcher } from 'undici';
 import { FatalError } from '#errors';
-import { serializeBodyAndInferContentType, serializeFetchResponse } from '#utils';
+import { ACTIVITY_GET_TRACE_DESTINATIONS, ACTIVITY_SEND_HTTP_REQUEST } from '#consts';
+import { serializeBodyAndInferContentType, serializeFetchResponse } from '#helpers/fetch';
 import { getTraceDestinations, sendHttpRequest } from './index.js';
 
 const getDestinationsMock = vi.hoisted( () => vi.fn() );
+const createInternalStepMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
 
 vi.mock( '#tracing', () => ( {
   getDestinations: getDestinationsMock
@@ -15,9 +17,15 @@ vi.mock( '#logger', () => {
   return { createChildLogger: vi.fn( () => log ) };
 } );
 
-vi.mock( '#utils', () => ( {
-  setMetadata: vi.fn(),
-  isStringboolTrue: vi.fn( () => false ),
+vi.mock( '#helpers/component', () => ( {
+  createInternalStep: createInternalStepMock
+} ) );
+
+vi.mock( '#helpers/string', () => ( {
+  isStringboolTrue: vi.fn( () => false )
+} ) );
+
+vi.mock( '#helpers/fetch', () => ( {
   serializeBodyAndInferContentType: vi.fn(),
   serializeFetchResponse: vi.fn()
 } ) );
@@ -30,6 +38,21 @@ setGlobalDispatcher( mockAgent );
 const url = 'https://growthx.ai';
 const method = 'GET';
 
+describe( 'internal_activities component registration', () => {
+  it( 'creates internal step components for exported activities', () => {
+    expect( createInternalStepMock ).toHaveBeenNthCalledWith( 1, {
+      name: ACTIVITY_SEND_HTTP_REQUEST,
+      handler: expect.any( Function )
+    } );
+    expect( createInternalStepMock ).toHaveBeenNthCalledWith( 2, {
+      name: ACTIVITY_GET_TRACE_DESTINATIONS,
+      handler: expect.any( Function )
+    } );
+    expect( sendHttpRequest ).toBe( createInternalStepMock.mock.calls[0][0].handler );
+    expect( getTraceDestinations ).toBe( createInternalStepMock.mock.calls[1][0].handler );
+  } );
+} );
+
 describe( 'internal_activities/sendHttpRequest', () => {
   beforeEach( async () => {
     vi.restoreAllMocks();

package/src/logger/development.js

@@ -1,5 +1,5 @@
 import { format, transports } from 'winston';
-import { isPlainObject, shuffleArray } from '#utils';
+import { shuffleArray, isPlainObject } from '#helpers/object';
 
 /** Available colors enum */
 const Color = {
@@ -47,7 +47,7 @@ const getColor = v =>
   assignedColors.get( v ) ?? assignedColors.set( v, COLORS[assignedColors.size % COLORS.length] ).get( v );
 
 export const options = {
-  level: 'debug',
+  level: process.env.OUTPUT_LOG_LEVEL ?? 'debug',
   transports: [ new transports.Console() ],
   format: format.combine(
     format.colorize(),

package/src/logger/development.spec.js

@@ -1,9 +1,9 @@
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
 const LEVEL = Symbol.for( 'level' );
 const MESSAGE = Symbol.for( 'message' );
 
-vi.mock( '#utils', () => ( {
+vi.mock( '#helpers/object', () => ( {
   isPlainObject: v => Object.prototype.toString.call( v ) === '[object Object]',
   shuffleArray: v => v
 } ) );
@@ -14,6 +14,10 @@ const loadDevelopmentLogger = async () => {
 };
 
 describe( 'logger/development', () => {
+  afterEach( () => {
+    vi.unstubAllEnvs();
+  } );
+
   describe( 'formatJson', () => {
     it( 'formats nested plain objects and arrays', async () => {
       const { formatJson } = await loadDevelopmentLogger();
@@ -40,6 +44,19 @@ describe( 'logger/development', () => {
   } );
 
   describe( 'options.format', () => {
+    it( 'uses debug level by default', async () => {
+      const { options } = await loadDevelopmentLogger();
+
+      expect( options.level ).toBe( 'debug' );
+    } );
+
+    it( 'uses OUTPUT_LOG_LEVEL when configured', async () => {
+      vi.stubEnv( 'OUTPUT_LOG_LEVEL', 'http' );
+      const { options } = await loadDevelopmentLogger();
+
+      expect( options.level ).toBe( 'http' );
+    } );
+
     it( 'formats level, namespace, message, and metadata fields', async () => {
       const { options } = await loadDevelopmentLogger();
       const info = options.format.transform( {

package/src/logger/production.js

@@ -1,7 +1,7 @@
 import { transports, format } from 'winston';
 
 export const options = {
-  level: 'info',
+  level: process.env.OUTPUT_LOG_LEVEL ?? 'info',
   transports: [ new transports.Console() ],
   defaultMeta: {
     service: 'output-worker',

package/src/logger/production.spec.js

@@ -1,11 +1,21 @@
-import { describe, expect, it } from 'vitest';
-import { options } from './production.js';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
 const LEVEL = Symbol.for( 'level' );
 const MESSAGE = Symbol.for( 'message' );
 
+const loadProductionLogger = async () => {
+  vi.resetModules();
+  return import( './production.js' );
+};
+
 describe( 'logger/production', () => {
-  it( 'uses info level and default production metadata', () => {
+  afterEach( () => {
+    vi.unstubAllEnvs();
+  } );
+
+  it( 'uses info level and default production metadata', async () => {
+    const { options } = await loadProductionLogger();
+
     expect( options.level ).toBe( 'info' );
     expect( options.defaultMeta ).toEqual( {
       service: 'output-worker',
@@ -13,7 +23,15 @@ describe( 'logger/production', () => {
     } );
   } );
 
-  it( 'formats logs as JSON with timestamp and metadata fields', () => {
+  it( 'uses OUTPUT_LOG_LEVEL when configured', async () => {
+    vi.stubEnv( 'OUTPUT_LOG_LEVEL', 'debug' );
+    const { options } = await loadProductionLogger();
+
+    expect( options.level ).toBe( 'debug' );
+  } );
+
+  it( 'formats logs as JSON with timestamp and metadata fields', async () => {
+    const { options } = await loadProductionLogger();
     const info = options.format.transform( {
       [LEVEL]: 'info',
       level: 'info',
@@ -33,7 +51,8 @@ describe( 'logger/production', () => {
     expect( output.timestamp ).toEqual( expect.stringMatching( /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}[+-]\d{2}:\d{2}$/u ) );
   } );
 
-  it( 'includes error stack when formatting Error messages', () => {
+  it( 'includes error stack when formatting Error messages', async () => {
+    const { options } = await loadProductionLogger();
     const error = new Error( 'boom' );
     const info = options.format.transform( {
       [LEVEL]: 'error',

package/src/sdk/helpers/index.d.ts

@@ -9,3 +9,4 @@
  */
 export * from './component_metadata.js';
 export * from './path.js';
+export * from './objects.js';

package/src/sdk/helpers/index.js

@@ -1,2 +1,3 @@
 export * from './component_metadata.js';
 export * from './path.js';
+export * from './objects.js';

package/src/sdk/helpers/objects.d.ts

@@ -0,0 +1,51 @@
+/** Tools to manipulate JS Objects */
+export declare const Objects: {
+  /**
+   * Node safe clone implementation that doesn't use global structuredClone().
+   *
+   * Returns a cloned version of the object.
+   *
+   * Only clones static properties. Getters become static properties.
+   *
+   * @param object
+   */
+  clone( object: object ): object,
+
+  /**
+   * Returns true if the value is a plain object:
+   * - `{}`
+   * - `new Object()`
+   * - `Object.create(null)`
+   *
+   * @param object - The value to check.
+   * @returns Whether the value is a plain object.
+   */
+  isPlainObject( object: unknown ): boolean,
+
+  /**
+   * Creates a new object by merging object `b` onto object `a`, biased toward `b`:
+   * - Fields in `b` overwrite fields in `a`.
+   * - Fields in `b` that don't exist in `a` are created.
+   * - Fields in `a` that don't exist in `b` are left unchanged.
+   *
+   * @param a - The base object.
+   * @param b - The overriding object.
+   * @throws {Error} If either `a` or `b` is not a plain object.
+   * @returns A new merged object.
+   */
+  deepMerge( a: object, b: object | null | undefined ): object,
+
+  /**
+   * Creates a new object by merging object `b` onto object `a`, biased toward `b`:
+   * - Fields in `b` that don't exist in `a` are created.
+   * - Fields in `a` that don't exist in `b` are left unchanged.
+   * - Fields in `a` and `b` are passed as arguments to the resolve function (a,b) and its return assigns the new value.
+   *
+   * @param a - The base object.
+   * @param b - The overriding object.
+   * @param resolver - The resolver function.
+   * @throws {Error} If either `a` or `b` is not a plain object.
+   * @returns A new merged object.
+   */
+  deepMergeWithResolver( a: object, b: object | null | undefined, resolver: ( a: unknown, b: unknown ) => unknown ): object
+};

package/src/sdk/helpers/objects.js

@@ -0,0 +1,8 @@
+import { clone, deepMerge, deepMergeWithResolver, isPlainObject } from '#helpers/object';
+
+export const Objects = {
+  clone,
+  deepMerge,
+  deepMergeWithResolver,
+  isPlainObject
+};

package/src/sdk/helpers/objects.spec.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { Objects } from './objects.js';
+import { Objects as ObjectsFromIndex } from './index.js';
+import { clone, deepMerge, deepMergeWithResolver, isPlainObject } from '#helpers/object';
+
+describe( 'Objects', () => {
+  it( 'exports the same functions from the object helper module', () => {
+    expect( Objects ).toBe( ObjectsFromIndex );
+    expect( Objects ).toEqual( {
+      clone,
+      deepMerge,
+      deepMergeWithResolver,
+      isPlainObject
+    } );
+  } );
+} );

package/src/tracing/processors/s3/redis_client.spec.js

@@ -1,11 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
-vi.mock( '#utils', () => ( {
-  throws: e => {
-    throw e;
-  }
-} ) );
-
 const logCalls = { warn: [], error: [] };
 vi.mock( '#logger', () => ( {
   createChildLogger: () => ( {

package/src/tracing/processors/s3/s3_client.spec.js

@@ -1,11 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-vi.mock( '#utils', () => ( {
-  throws: e => {
-    throw e;
-  }
-} ) );
-
 const getVarsMock = vi.fn();
 vi.mock( './configs', () => ( { getVars: () => getVarsMock() } ) );
 

package/src/tracing/trace_engine.js

@@ -1,7 +1,7 @@
 import { Storage } from '#async_storage';
 import { EventEmitter } from 'node:events';
 import { serializeError } from './tools/utils.js';
-import { isStringboolTrue } from '#utils';
+import { isStringboolTrue } from '#helpers/string';
 import * as localProcessor from './processors/local/index.js';
 import * as s3Processor from './processors/s3/index.js';
 import { ComponentType } from '#consts';

package/src/worker/catalog_workflow/catalog_job.js

@@ -3,7 +3,7 @@ import { WorkflowExecutionAlreadyStartedError, WorkflowIdConflictPolicy } from '
 import { WORKFLOW_CATALOG } from '#consts';
 import { catalogId, taskQueue } from '../configs.js';
 import { createChildLogger } from '#logger';
-import { CancellablePromise } from '#utils';
+import { CancellablePromise } from '#helpers/promise';
 
 const log = createChildLogger( 'Catalog' );
 

package/src/worker/catalog_workflow/index.spec.js

@@ -7,9 +7,6 @@ vi.mock( '#consts', () => ( {
   METADATA_ACCESS_SYMBOL
 } ) );
 
-const setMetadata = ( target, values ) =>
-  Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
-
 describe( 'createCatalog', () => {
   it( 'builds catalog with activities grouped by workflow path and returns Catalog with CatalogWorkflow entries', async () => {
     const { createCatalog } = await import( './index.js' );
@@ -32,40 +29,40 @@ describe( 'createCatalog', () => {
     ];
 
     const activity1 = () => {};
-    setMetadata( activity1, {
+    activity1[METADATA_ACCESS_SYMBOL] = {
       name: 'A1',
       path: '/flows/flow1#A1',
       description: 'desc-a1',
       inputSchema: z.object( { in: z.literal( 'a1' ) } ),
       outputSchema: z.object( { out: z.literal( 'a1' ) } )
-    } );
+    };
 
     const activity2 = () => {};
-    setMetadata( activity2, {
+    activity2[METADATA_ACCESS_SYMBOL] = {
       name: 'A2',
       path: '/flows/flow1#A2',
       description: 'desc-a2',
       inputSchema: z.object( { in: z.literal( 'a2' ) } ),
       outputSchema: z.object( { out: z.literal( 'a2' ) } )
-    } );
+    };
 
     const activity3 = () => {};
-    setMetadata( activity3, {
+    activity3[METADATA_ACCESS_SYMBOL] = {
       name: 'B1',
       path: '/flows/flow2#B1',
       description: 'desc-b1',
       inputSchema: z.object( { in: z.literal( 'b1' ) } ),
       outputSchema: z.object( { out: z.literal( 'b1' ) } )
-    } );
+    };
 
     const activity4 = () => {};
-    setMetadata( activity4, {
+    activity4[METADATA_ACCESS_SYMBOL] = {
       name: 'X',
       path: '/other#X',
       description: 'desc-x',
       inputSchema: z.object( { in: z.literal( 'x' ) } ),
       outputSchema: z.object( { out: z.literal( 'x' ) } )
-    } );
+    };
 
     const activities = {
       '/flows/flow1#A1': activity1,

package/src/worker/configs.js

@@ -1,5 +1,5 @@
 import * as z from 'zod';
-import { isStringboolTrue } from '#utils';
+import { isStringboolTrue } from '#helpers/string';
 
 class InvalidEnvVarsErrors extends Error { }
 

package/src/worker/connection_monitor.js

@@ -1,6 +1,6 @@
 import { createChildLogger } from '#logger';
 import { setTimeout as delay } from 'node:timers/promises';
-import { CancellablePromise } from '#utils';
+import { CancellablePromise } from '#helpers/promise';
 
 const log = createChildLogger( 'Connection' );
 

package/src/worker/global_functions.js

@@ -0,0 +1,14 @@
+import { messageBus } from '#bus';
+import { ACTIVITY_LOGGER_SYMBOL, BusEventType } from '#consts';
+import { activityInfo as activityInfoFn } from '@temporalio/activity';
+import { assignImmutableProperty } from '#helpers/object';
+
+/**
+ * Sets global functions on globalThis
+ */
+export const bindGlobalFunctions = () => {
+  /** Defines the activity logger function, accessible in activity context via logger interface */
+  assignImmutableProperty( globalThis, ACTIVITY_LOGGER_SYMBOL, ( { level, message, metadata } ) =>
+    messageBus.emit( BusEventType.ACTIVITY_LOG, { level, message, metadata, activityInfo: activityInfoFn() } )
+  );
+};

package/src/worker/global_functions.spec.js

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const {
+  ACTIVITY_LOGGER_SYMBOL,
+  BusEventType
+} = vi.hoisted( () => ( {
+  ACTIVITY_LOGGER_SYMBOL: Symbol( 'activity_logger' ),
+  BusEventType: {
+    ACTIVITY_LOG: 'activity:log'
+  }
+} ) );
+
+const messageBusMock = vi.hoisted( () => ( {
+  emit: vi.fn()
+} ) );
+const activityInfoMock = vi.hoisted( () => vi.fn( () => ( {
+  activityId: 'act-1',
+  activityType: 'myStep'
+} ) ) );
+
+vi.mock( '#consts', () => ( { ACTIVITY_LOGGER_SYMBOL, BusEventType } ) );
+vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '@temporalio/activity', () => ( {
+  activityInfo: activityInfoMock
+} ) );
+
+describe( 'worker/global_functions', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    delete globalThis[ACTIVITY_LOGGER_SYMBOL];
+  } );
+
+  it( 'binds activity logger global function that emits activity log events with metadata', async () => {
+    const { bindGlobalFunctions } = await import( './global_functions.js' );
+    const metadata = { requestId: 'req-1' };
+
+    bindGlobalFunctions();
+    globalThis[ACTIVITY_LOGGER_SYMBOL]( {
+      level: 'debug',
+      message: 'activity detail',
+      metadata
+    } );
+
+    expect( activityInfoMock ).toHaveBeenCalledTimes( 1 );
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.ACTIVITY_LOG, {
+      level: 'debug',
+      message: 'activity detail',
+      metadata,
+      activityInfo: {
+        activityId: 'act-1',
+        activityType: 'myStep'
+      }
+    } );
+  } );
+} );

package/src/worker/index.js

@@ -17,7 +17,8 @@ import { messageBus } from '#bus';
 import { BusEventType } from '#consts';
 import { setupTelemetry } from './telemetry.js';
 import { TemporalConnectionMonitor } from './connection_monitor.js';
-import { runOnce } from '#utils';
+import { bindGlobalFunctions } from './global_functions.js';
+import { runOnce } from '#helpers/function';
 
 import './log_hooks.js';
 
@@ -76,6 +77,8 @@ const execute = async () => {
     log.info( 'Using gRPC proxy', { targetHost: grpcProxy } );
   }
 
+  bindGlobalFunctions();
+
   state.connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey, proxy } );
 
   log.info( 'Creating connection monitor...' );

package/src/worker/index.spec.js

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 const {
   catalogJobInstance,
+  bindGlobalFunctionsMock,
   configValues,
   connectionMonitorInstance,
   createCatalogMock,
@@ -98,6 +99,7 @@ const {
 
   return {
     catalogJobInstance,
+    bindGlobalFunctionsMock: vi.fn(),
     configValues,
     connectionMonitorInstance,
     createCatalogMock: vi.fn().mockReturnValue( { workflows: [], activities: {} } ),
@@ -145,6 +147,7 @@ vi.mock( './interceptors/index.js', () => ( { initInterceptors: initInterceptors
 vi.mock( './proxy.js', () => ( { bootstrapFetchProxy: vi.fn() } ) );
 vi.mock( './telemetry.js', () => ( { setupTelemetry: setupTelemetryMock } ) );
 vi.mock( './interruption.js', () => ( { setupInterruptionHandler: setupInterruptionHandlerMock } ) );
+vi.mock( './global_functions.js', () => ( { bindGlobalFunctions: bindGlobalFunctionsMock } ) );
 vi.mock( './connection_monitor.js', () => ( {
   TemporalConnectionMonitor: vi.fn( function () {
     return connectionMonitorInstance;
@@ -222,6 +225,10 @@ describe( 'worker/index', () => {
       apiKey: undefined,
       proxy: undefined
     } );
+    expect( bindGlobalFunctionsMock ).toHaveBeenCalledTimes( 1 );
+    expect( bindGlobalFunctionsMock.mock.invocationCallOrder[0] ).toBeLessThan(
+      NativeConnection.connect.mock.invocationCallOrder[0]
+    );
     expect( TemporalConnectionMonitor ).toHaveBeenCalledWith( mockConnection );
     expect( CatalogJob ).toHaveBeenCalledWith( {
       connection: mockConnection,

package/src/worker/interceptors/activity.js

@@ -5,8 +5,8 @@ import { headersToObject } from './headers.js';
 import { ACTIVITY_WRAPPER_VERSION_FIELD, BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
 import { messageBus } from '#bus';
-import { aggregateAttributes } from '#internal_utils/aggregations';
-import { buildApplicationFailureWithDetails } from '#internal_utils/errors';
+import { aggregateAttributes } from '#helpers/aggregations';
+import { buildApplicationFailureWithDetails } from '#helpers/errors';
 
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:

package/src/worker/interceptors/workflow.js

@@ -1,10 +1,10 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 import { workflowInfo, proxySinks, ContinueAsNew, isCancellation } from '@temporalio/workflow';
 import { memoToHeaders } from './headers.js';
-import { deepMerge } from '#utils';
-import { buildApplicationFailureWithDetails } from '#internal_utils/errors';
+import { deepMerge } from '#helpers/object';
+import { buildApplicationFailureWithDetails } from '#helpers/errors';
 import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
-import { createWorkflowDetails } from '#internal_utils/temporal_context';
+import { createWorkflowDetails } from '#helpers/temporal_context';
 
 // this is a dynamic generated file with activity configs overwrites
 import stepOptions from '../temp/__activity_options.js';

package/src/worker/interceptors/workflow.spec.js

@@ -54,7 +54,7 @@ const memoToHeadersMock = vi.fn( memo => ( memo ? { ...memo, __asHeaders: true }
 vi.mock( './headers.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMock( ...args ) } ) );
 
 const deepMergeMock = vi.fn( ( a, b ) => ( { ...( a || {} ), ...( b || {} ) } ) );
-vi.mock( '#utils', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );
+vi.mock( '#helpers/object', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );
 
 const stepOptionsDefault = {};
 vi.mock( '../temp/__activity_options.js', () => ( { default: stepOptionsDefault } ) );

package/src/worker/loader/matchers.js

@@ -1,5 +1,5 @@
 import { sep } from 'node:path';
-import { rxEscape } from '#utils';
+import { rxEscape } from '#helpers/string';
 
 /**
  * Creates a matcher function that based on "path", matches: