Exports

Publish a custom web app onto the laptop desktop, Start menu, taskbar, and Spotlight. Called on the server it broadcasts to all players and replays to late joiners. Called on a client it adds the app on that client only. Re-call with the same id to update the app live. Gated by Config.Apps.External.

CreateThread(function()
    Wait(1500)
    exports['nx_computer']:RegisterApp({
        id = 'pizzaplanet',
        url = 'https://apps.example.com/pizzaplanet',
        title = 'Pizza Planet',
        accent = '#e23b3b',
        width = 1024,
        height = 720,
    })
end)

Remove a previously registered custom app by its id. Server and client scope match RegisterApp.

exports['nx_computer']:UnregisterApp('pizzaplanet')

Publish a built-in .lc directory site inside the laptop browser, for example pizzaplanet.lc. Called on the server it broadcasts to all players and replays to late joiners. Called on a client it registers on that client only. Re-call with the same slug to update live. Gated by Config.SiteBuilder.Directory.

CreateThread(function()
    Wait(1500)
    exports['nx_computer']:RegisterSite({
        slug = 'pizzaplanet',
        url = 'https://apps.example.com/pizzaplanet-site',
        title = 'Pizza Planet',
        description = 'Order delivery across the city.',
    })
end)

Remove a registered directory site by slug and release the slug for player use. Server and client scope match RegisterSite.

exports['nx_computer']:UnregisterSite('pizzaplanet')

Deliver a system or automated email into a player's laptop inbox from another resource. Returns the new email id, or false when the recipient cannot be resolved. The recipient's email forwarding rules apply to system mail too.

exports['nx_computer']:sendSystemEmail({
    to = '@jdoe',
    subject = 'Your order shipped',
    body = 'Your package is on the way.',
    sourceApp = 'store',
    senderName = 'Pizza Planet',
})

Push a notification into a player's laptop notification centre. It appears immediately if that account is signed in, and waits in the centre otherwise. Returns the new notification id, or nil when the target cannot be resolved or the title or message is empty.

exports['nx_computer']:PushNotification({
    handle = '@jdoe',
    appId = 'store',
    title = 'Order ready',
    message = 'Your pizza is waiting at the counter.',
    severity = 'success',
})

Raise a notification on the player's phone through the phone bridge. Returns false when the bridge is off, the kind is not enabled in Config.PhoneBridge.Events, the player is not online, or there is no text to show. It never throws.

-- config.lua: Config.PhoneBridge.Events = { Email = true, Message = true, Dispatch = true }
exports['nx_computer']:PhoneNotify(source, 'Dispatch', {
    title = 'Dispatch',
    body = '10-50 reported at Legion Square.',
})

Resolve the identifier of the character a player is currently playing. This is the key laptop accounts are bound to. Returns nil when the player or their character cannot be resolved.

local actor = exports['nx_computer']:GetActorIdentifier(source)

Look up the laptop account bound to a character. When the character has several accounts, this returns the primary one. Returns the stored account record, or nil when no live account matches.

local actor = exports['nx_computer']:GetActorIdentifier(source)
local account = actor and exports['nx_computer']:GetAccountByActor(actor)
if account then
    print(account.username)
end

Look up an account by its account id. Same record and same caution as GetAccountByActor. Returns nil for an unknown or deleted account.

Look up an account by its username. Same record and same caution as GetAccountByActor. Returns nil for an unknown or deleted account.

Every live account a character owns, primary first, then oldest first. Returns an empty table when there are none. Each entry is the same record GetAccountByActor returns, with the same caution.

local actor = exports['nx_computer']:GetActorIdentifier(source)
for _, account in ipairs(exports['nx_computer']:GetAccountsByActor(actor)) do
    print(account.username)
end

The account a player is using right now. That is the account signed in on their laptop when a session is open, and the character's primary account otherwise. A session left over from a different character on the same player is ignored. Same record and same caution as GetAccountByActor.

local account = exports['nx_computer']:ResolveActorAccount(source)

The same resolution as ResolveActorAccount, for code that holds a character identifier instead of a server id. If that character has a laptop session open, its signed-in account is returned. Otherwise the primary account.

Return the display-safe summary of an account. This is the shape to send to a client. Returns nil for an unknown account.

local summary = exports['nx_computer']:ResolveAccountSummary(accountId)

Whether a player holds the nx_computer.admin ACE. The broad command ACE is not accepted unless Config.AllowCommandAceAdmin is enabled. Use it to gate your own admin surfaces on the same principal nx_computer uses.

if not exports['nx_computer']:IsAdmin(source) then return end

Whether a player may use the /nxc_place and /nxc_cable placement tools. True for everyone while Config.Debug is on. Otherwise true for holders of the nx_computer.admin ACE and for framework admins, unless Config.PlacerAdminAccess is false. Never throws.

List laptop devices, most recently updated first. This is the list the Admin app shows. The search matches the start of a computer id or of the owner's or last user's username. limit is clamped to 1 through 100. The export does no permission check of its own, so gate the caller.

local result = exports['nx_computer']:AdminListComputers({ search = '@jdoe', limit = 20 })
for _, computer in ipairs(result.computers) do
    print(computer.computerId, computer.deviceName)
end

The mail domain this server uses right now, for example 'yourcity.com'.

local domain = exports['nx_computer']:GetMailDomain()

Build the full mail address for a username, for example '[email protected]'. Returns nil for input that is not a valid username.

local address = exports['nx_computer']:MailAddressFor('@jdoe')

Find the account a mail address belongs to. Accepts the current domain and any older domain the server has used. A live account wins over an old name of a renamed account. Returns nil for a foreign domain or an unknown name.

local match = exports['nx_computer']:ResolveMailAddress('[email protected]')
if match then
    print(match.account_id, match.address)
end

Send an email as a player, exactly as if they had pressed Send in the Email app. A copy lands in the sender's Sent folder. Returns { success, item, counts } on success, or { success = false, error } with an error such as invalid_account.

local result = exports['nx_computer']:SendEmailFromAccount(
    accountId, '@jdoe', 'Meeting', 'See you at six.'
)

Post a classifieds listing as a player. Only resources named in Config.Classifieds.ExportResources may call it. That list defaults to nx_phone, and any other caller gets { success = false, error = 'forbidden' }. Returns { success, listing } on success.

local result = exports['nx_computer']:CreateClassifiedForAccount(accountId, {
    category = 'for-sale',
    title = 'Used Blista',
    body = 'Runs well. Some rust.',
    priceText = '$4,000',
})

Remove one of a player's own classifieds listings. The same caller allow-list as CreateClassifiedForAccount applies. Returns { success } or { success = false, error }.

Create a laptop account for the character a player is playing, with the same username, PIN and account-limit rules as signing up on a laptop. Only resources named in Config.AccountExportResources may call it. That list defaults to nx_phone. Returns { success = true, accountId, account }, or { success = false, error }.

local result = exports['nx_computer']:CreateAccountForCharacter(source, {
    username = 'jdoe',
    displayName = 'John Doe',
    pin = '4821',
})

Whether a player physically controls a laptop: they are carrying it, or standing within Config.PickupMaxDistance of where it is placed. Use it to gate anything that should require possession of a specific device.

if exports['nx_computer']:IsSourceNearComputer(source, computerId) then
    -- the player can reach this laptop
end

Read a player's cash and bank balances through the configured framework. Returns whole-dollar integers, and zeros when the player is offline or unknown.

local balances = exports['nx_computer']:GetPlayerBalances(source)
print(balances.cash, balances.bank)

Write an entry into the laptop's Wallet ledger so a money movement your resource performed shows up in the player's transaction history. Returns false when a required field is missing or the entry type is not recognised.

exports['nx_computer']:RecordTransaction({
    computerId = computerId,
    accountId = accountId,
    entryType = 'job_payout',
    assetSymbol = 'USD',
    assetAmount = 1,
    fiatTotal = 850,
    counterpartyLabel = 'Pizza Planet',
    referenceId = 'shift-4471',
})

Roll one hand into the player's open casino session so a game your resource runs lands in the same session ledger the built-in tables use. The session commits itself after an idle period, a hand cap, or when the player disconnects. Returns false for an unknown game type or a missing account.

exports['nx_computer']:RecordCasinoHandResult(
    source, accountId, computerId, 'blackjack', 250, 500
)

Append an entry to the security audit log that the admin console reads. Returns the new entry id, or nil when the action is empty.

exports['nx_computer']:WriteAudit({
    action = 'store.refund',
    actorAccountId = accountId,
    severity = 'notice',
    detail = { orderId = 4471, amount = 250 },
})

The current price of one asset. Returns nil for an unknown symbol or before the engine is live.

local price = exports['nx_computer']:MarketGetPrice('NXC')

The full public snapshot for one asset. Returns nil for an unknown symbol or before the engine is live.

local asset = exports['nx_computer']:MarketGetAsset('NXC')
if asset then
    print(asset.name, asset.price, asset.regime)
end

Every asset's snapshot, in the same shape MarketGetAsset returns. Returns an empty table before the engine is live.

for _, asset in ipairs(exports['nx_computer']:MarketListAssets()) do
    print(asset.symbol, asset.price)
end

Price history for one asset, oldest first, with the live in-progress candle appended last. Returns an empty table for an unknown symbol or an unrecognised resolution.

local candles = exports['nx_computer']:MarketGetCandles('NXC', '1h', 48)

Recent market events, newest first. Only moves that clear a newsworthiness bar are published, so this is a headline feed rather than every tick.

local events = exports['nx_computer']:MarketRecentEvents(os.time() - 3600, 10)

The player's current job as { name, label }. Returns nil when the player has no job, or when the job is unemployed or none.

local job = exports['nx_computer']:GetJobInfoForSource(source)
if job then print(job.name, job.label) end

The character identifiers of everyone in a job, online and offline, without duplicates. Capped at 250 and cached for 60 seconds per job. Returns an empty table for an unknown job and never throws.

for _, identifier in ipairs(exports['nx_computer']:GetJobMemberIdentifiers('police')) do
    local account = exports['nx_computer']:ResolveActorAccountByIdentifier(identifier)
end

Every open posting on a published player site, newest first. Returns an empty table when there are none.

local postings = exports['nx_computer']:GetPublishedSitePostings()

Whether a posting is still open on a still-published site. Check this before accepting an application against a posting id.

The saved application-form schema for one posting, so answers can be rendered with their labels instead of raw ids. Returns an empty table when the posting has no questions or does not exist.

The newspaper.lc front page: the same city-wide edition every player sees, built from real server activity. It needs no session and no allow-list.

local edition = exports['nx_computer']:NewsEdition()

Open in-world photo mode. This is the ox_inventory usable-item entry point for the camera item, wired as client = { export = 'nx_computer.useCamera' } in the item definition. It requires the screencapture (screenshot-basic) resource. Captured shots sync to the Photos app for the active account.

-- ox_inventory item definition
['camera'] = {
    label = 'Camera',
    weight = 500,
    stack = false,
    client = { export = 'nx_computer.useCamera' },
},

Hold a printed polaroid up to look at it. Nearby players see the photo on the prop. This is the ox_inventory usable-item entry point for the polaroid item, wired as client = { export = 'nx_computer.usePolaroid' }. A polaroid with no stored photo is refused.

-- ox_inventory item definition
['polaroid'] = {
    label = 'Polaroid',
    weight = 10,
    stack = false,
    client = { export = 'nx_computer.usePolaroid' },
},

Start placing a printed polaroid on a wall or a surface. It takes the same two arguments ox_inventory passes to a client export, so it can be bound to a secondary action on the polaroid item. The same placement flow is reachable in game while holding a polaroid.