Reach beyond
the browser.

// Queue the sale — travels when the line is up
await Arda.db.push('sales', sale)

// Bytes for the printer; the receipt layout is yours
const [printer] = await Arda.printers.list()
if (printer?.usable) {
  await Arda.printers.print(printer.id, escpos({
    width: printer.dots,   // 576 · corrected in the portal if wrong
    lines: renderReceipt(sale),
    cut:   true, drawer: true,
  }))
}

// A USB QR scanner is a keyboard wedge — attributed per device
Arda.on('barcode', async (scan) => {
  const members = await Arda.db.dataset('members')
  const m = members[scan.text]
  if (!m) return ui.refuse('Not a member')

  // The barrier relay hangs off a USB-serial adapter
  const [port] = await Arda.serial.list()
  await Arda.serial.open(port.id, { baud: 9600 })
  await Arda.serial.write(port.id, openPulse())

  await Arda.db.push('entries', { member: m.id, at: now() })
})

// A till has no keyboard. Ask for one when you need it.
const r = await Arda.keyboard({
  layout: 'numeric',
  fields: [
    { name: 'price', caption: 'Price', prefix: '£', decimals: 2, pos: true },
    { name: 'date',  caption: 'Collect on', mask: '00/00/0000' },
  ],
})
if (r === null) return           // cancelled
// r.price === '4.50'   r.date === '12/03/2026'

// A manager's PIN — the one layout a real keyboard can type into
const pin = await Arda.keyboard({ layout: 'pin', title: 'Override' })

// The customer display is a real Document
await Arda.screens.ready()
const total = document.createElement('div')
Arda.screen['customer']?.body.appendChild(total)
total.textContent = '£12.99'     // still updates the other screen

// Dim the panel at night, remembered across reboots
await Arda.screens.set(null, { brightness: 30 }, true)
await Arda.audio.set({ volume: 40 })

// And when the shop closes
await Arda.system.shutdown()

// The stream URL carries the camera's password —
// keep it in a per-device secret setting, not in the app
const [bay] = Arda.config.cameras ?? []   // a 'rows' setting
await Arda.camera.set('bay', { url: bay.url, fps: 15 })

// Its own H.264 in a <video>, or motion JPEG where the
// engine cannot decode it. Falls behind? It jumps to live.
const stop = Arda.camera.play('bay', document.getElementById('cctv'), {
  fit: 'cover', maxLag: 2.5,
})

// The order is safe first — the outbox never waits on the network
await Arda.db.push('orders', order)

// Then tell the kitchen system now. ArdaForm makes the call,
// signed, so the kitchen's key never sits on the till.
try {
  const r = await Arda.webhook.call('kitchen', { order: order.id, items: order.items })
  if (!r.ok) ui.warn('Kitchen answered ' + r.status)  // an answer, not an error
} catch (e) {
  ui.warn(e.message)   // nobody was asked: offline, limit reached…
}

// 23 copies in one job, over one connection (v1.1.11)
const stop = new AbortController()
await Arda.printers.print(label.id, tspl(tote), { copies: 23, signal: stop.signal }, (s) => {
  if (s.state === 'printing') ui.show(s.done + ' of ' + s.copies)
  if (s.state === 'stalled')  ui.show('Printer stopped: ' + s.code)  // not the end:
})                                         // it carries on when the roll is in
// stop.abort() ends it between copies, never inside one.
// confirmed: false means the printer TOOK the copy, not that it came
// out — most printers say nothing back, so time the paper yourself.

// A device with two monitors: the app on one, a camera full-screen
// on the other, drawn by the player itself (v1.1.12). Needs a PC-type
// (x86) device installed from the v1.1.12 images or later; the Raspberry
// Pi image does not have it yet, nor does a device that only got the player.
const [wall] = Arda.screens.list().filter((s) => s.kind === 'video')
if (wall) {
  await Arda.camera.set('yard', { url: Arda.config.yard_camera })   // rtsp://…
  await Arda.camera.show('yard', { screen: wall.name })
}
// show(null, {screen}) clears it; shows() says what is on each screen.
// Which monitor is the app's: the portal's Primary screen, or
// Arda.screens.set(name, {primary: true}) — once, not on every load.
// A monitor plugged in or switched on later (v1.1.13): list() is current
// inside the listener, so adopt the new video monitor there.
Arda.on('screens', () => {
  const w = Arda.screens.list().find((s) => s.kind === 'video')
  if (w) Arda.camera.show('yard', { screen: w.name })
})

<script src="/_arda/gui.js"></script>
<script>
// Once the portal has said what is being edited
ArdaGUI.ready(function (ctx) {
  draw(ArdaGUI.definitions, ArdaGUI.values)
})
// Saved, or changed in the standard form
ArdaGUI.on('values', function (values) {
  draw(ArdaGUI.definitions, values)
})
// A proposal: nothing is saved until the operator presses Update
slider.onchange = function () {
  ArdaGUI.set('font_size', Number(slider.value)).then(function (r) {
    if (!r.ok) showErrors(r.errors)   // {font_size: 'Text size must be a number'}
  })
}
</script>