# Script Integrations

If you want to use your own server scripts, the real source points to these integration locations:

* Inventory: `modules/inventory/server.lua`
* Target: `modules/target/client.lua`
* Notify, progressbar, and helper functions: `modules/utils/client.lua`
* Server-side helper functions: `modules/utils/server.lua`

## Inventory Integration

File: `modules/inventory/server.lua`

Use this file if your server does not match the default inventory logic.

This usually means adapting:

* Give item
* Remove item
* Check item
* Count item

Basic example:

```lua
function Inventory.giveItem(source, itemName, count)
    return exports['my_inventory']:AddItem(source, itemName, count)
end
```

## Target Integration

File: `modules/target/client.lua`

If you use a custom target system, adapt your zone and bench interaction logic here.

This usually includes:

* Adding zones
* Removing zones
* Adding entity interactions
* Removing entity interactions

## Notify and Progressbar

File: `modules/utils/client.lua`

Most custom integrations happen here.

Common changes:

* Replace notify logic
* Replace progressbar logic
* Replace helper functions used during crafting

Notify example:

```lua
function Utils.notify(title, type, duration, description)
    exports['my_notify']:Send({
        title = title,
        description = description,
        type = type,
        duration = duration
    })
end
```

Progressbar example:

```lua
function Utils.progressBar(data)
    return exports['my_progressbar']:Progress(data)
end
```

## Server-Side Helpers

File: `modules/utils/server.lua`

Use this file if your server needs custom server-side helper behavior.

Common examples:

* Reward handling
* Server-side notifications
* Shared crafting utilities

## Safest Way To Integrate

Use this order:

1. Read the existing function and keep the same input/output behavior.
2. Replace only the integration-specific lines with your own export or event.
3. Do not change return types unless you know the script expects it.
4. Test crafting, queue handling, and bench interaction in game.