Quickstart: send your first local message

import { OfflineProtocol, MessagePriority } from '@offline-protocol/mesh-sdk';

export const discoveredPeers = new Set<string>();
export const readyPeers = new Set<string>();

export const protocol = new OfflineProtocol({
  appId: 'field-handoff',
  profile: 'default',
  transports: {
    ble: { enabled: true },
    internet: { enabled: false },
    wifiDirect: { enabled: false },
    nostr: { enabled: false },
    reticulum: { enabled: false },
  },
});

protocol.on('identity_ready', (event) => {
  if (event.type !== 'identity_ready') return;
  const { address } = event;
  console.log('This device:', address);
});
protocol.on('neighbor_discovered', (event) => {
  if (event.type !== 'neighbor_discovered') return;
  const { peer_id, transport } = event;
  discoveredPeers.add(peer_id);
  // Sessions survive stop/start; a new establishment event is not guaranteed.
  void protocol.mlsHasSession(peer_id).then(hasSession => {
    if (hasSession) readyPeers.add(peer_id);
  }).catch(error => console.error("Session lookup failed:", error));
  console.log('Nearby device:', peer_id, transport);
});
protocol.on('secure_session_established', (event) => {
  if (event.type !== 'secure_session_established' || !event.is_session) return;
  const { peer_id } = event;
  readyPeers.add(peer_id);
  console.log('Encrypted session ready:', peer_id);
});
protocol.on('message_received', (event) => {
  if (event.type !== 'message_received') return;
  const { sender, content } = event;
  console.log('Received:', sender, content);
});
protocol.on('message_delivered', (event) => {
  if (event.type !== 'message_delivered') return;
  const { message_id } = event;
  console.log('Delivered:', message_id);
});
protocol.on('message_failed', (event) => {
  if (event.type !== 'message_failed') return;
  const { message_id, reason } = event;
  console.error('Failed:', message_id, reason);
});

export async function startMesh() {
  await protocol.start();
  if (!(await protocol.localAddress())) {
    await protocol.stop();
    throw new Error('Identity initialization failed; inspect diagnostics and secure storage');
  }
}

export async function sendUpdate(peerAddress: string) {
  return protocol.sendMessage({
    recipient: peerAddress,
    content: JSON.stringify({ type: 'inspection', asset: 'pump-17', status: 'checked' }),
    priority: MessagePriority.High,
  });
}

export async function stopMesh() {
  await protocol.stop();
  readyPeers.clear();
  discoveredPeers.clear();
}

// Final teardown only. This instance cannot be reused after destroy().
export async function destroyMesh() {
  await protocol.stop();
  await protocol.destroy();
  readyPeers.clear();
  discoveredPeers.clear();
}