@teincfood/core 0.7.9 → 0.8.1

package/dist/index.js

@@ -7,6 +7,9 @@
 // ── Types ──
 export * from "./types/api";
 export * from "./types/pos.types";
+export * from "./types/rider";
+export * from "./types/places";
+export * from "./adapters/notify";
 // ── Pricing (server-parity) ──
 export { calculatePricing, calculateTaxLines, calculateExclusiveTax, calculateInclusiveTaxShare, } from "./pricing/engine";
 // ── Utils ──
@@ -15,14 +18,29 @@ export * from "./utils/currency";
 export * from "./utils/error";
 export * from "./utils/uuid";
 export * from "./utils/sync-logger";
+export * from "./utils/debug-log";
+export * from "./utils/attempt-stats";
 export { PHONE_COUNTRIES, getDialCodeFromCountry, getCountryOption, normalizePhoneForCountry, isLikelyE164 } from "./utils/phone";
 export * from "./utils/formatCurrency";
 export { formatDate, formatRelativeTime } from "./utils/formatDate";
 export * from "./utils/validation";
-export * from "./utils/responsive";
+export * from "./validation/offline";
 export * from "./utils/copyToClipBoard";
 export * from "./utils/customer-display";
 export * from "./utils/order-filter";
+export { useReferenceData } from "./reference/hooks";
+export { setNotifyHandlers } from "./adapters/notify";
+export { walletService, riderService, fleetService, deliveryService, dashboardService, analyticsService, placesService } from "./adapters/services";
+export { buildMenuItemEnvelope, buildMenuCategoryEnvelope } from "./reference/menu-record";
+export { validateMenuItemInput, validateMenuCategoryInput, validateOrderCreateInput, validateInviteInput } from "./validation/offline";
+export { useBusinessDeliveriesQuery } from "./hooks/delivery.hooks";
+export { useBusinessReferenceDataSync } from "./reference/hooks";
+export { createAppQueryClient, createQueryPersister } from "./providers/query-client";
+export { useSellerAnalyticsQuery } from "./hooks/analytics.hooks";
+export { useSellerDashboardQuery } from "./hooks/dashboard.hooks";
+export { useRealtimeInvalidation, useOrderRealtimeUpdates } from "./hooks/realtime-stubs";
+export { useAcceptFleetInvitationMutation, useAcceptBusinessInvitationMutation, useUserInvitationsQuery, } from "./hooks/members.hooks";
+export { useJoinRequestsQuery } from "./hooks/fleet.hooks";
 // ── DB ──
 export * from "./db/migrations";
 export * from "./db/operations";
@@ -30,10 +48,10 @@ export * as dbOps from "./db/operations";
 export { openSyncDatabase, getSyncDatabase, closeSyncDatabase } from "./db/connection";
 // ── Sync ──
 export * from "./sync/types";
+export * from "./sync/online-gates";
 export * from "./sync/use-sync-reconciliation";
 export { SyncEngine, syncEngine } from "./sync/engine";
 export * from "./sync/command-builder";
-export * from "./sync/command-queue.service";
 export { commandQueueService } from "./sync/command-queue.service";
 export { buildCommand } from "./sync/command-builder";
 export { generateLocalOrderNumber, generateLocalCalloutNumber, isLocalOrderNumber, generateOrderNumber, generateOrderNumberForBusiness, isOfflineOrderNumber, parseOrderNumber, resetCalloutForTests, } from "./sync/order-number";
@@ -55,30 +73,54 @@ export { orderRepository } from "./repositories/order.repository";
 export { posRepository } from "./repositories/pos.repository";
 // ── Order lifecycle hooks (offline-first, device-owned outbox) ──
 export * from "./hooks/orders.hooks";
+export * from "./hooks/use-infinite-list";
+export * from "./hooks/wallet.hooks";
+export * from "./hooks/rider.hooks";
+export * from "./hooks/fleet.hooks";
+export * from "./hooks/delivery.hooks";
+export * from "./hooks/dashboard.hooks";
+export * from "./hooks/analytics.hooks";
+export * from "./hooks/members.hooks";
+export * from "./hooks/places.hooks";
+export * from "./hooks/offline-orders.hooks";
+export * from "./hooks/image.hooks";
+export * from "./hooks/realtime-stubs";
+export * from "./providers/query-client";
+export { KIOSK_KEYS, useKioskOrdersQuery, useAvailableRidersQuery, useAcceptKioskOrderMutation, useRejectKioskOrderMutation, useStartPreparingKioskOrderMutation, useMarkKioskOrderReadyMutation, } from "./hooks/kiosk.hooks";
 // ── Reference ──
 export * from "./reference/types";
 export * from "./reference/operations";
-export { fetchReferenceVersions, fetchReferenceData, fetchReferenceChanges, setReferenceLocalNodeFetcher } from "./reference/api";
+export { fetchReferenceVersions, fetchReferenceData, fetchReferenceChanges, setReferenceLocalNodeFetcher, setReferenceData, mergeReferenceData, setOperatingHoursLocal, setBusinessProfileLocal } from "./reference/api";
 export { emitReferenceChanged, applyReferenceChangeEvent, syncReferenceDataOnReconnect, registerReferenceEventEngine, registerReferenceInvalidator } from "./reference/events";
 export * from "./reference/events";
 export * from "./reference/service";
+export * from "./reference/hooks";
 export { referenceSyncService } from "./reference/service";
+export * from "./reference/menu-record";
+export * from "./reference/menu-apply";
 export * from "./reference/capabilities";
 // ── Adapters (for host apps to supply) ──
 export * from "./adapters/sqlite";
 export { setKVDriver, getKVDriver, kvGetItem, kvSetItem, kvRemoveItem, getItem, setItem, removeItem, getItemSync, setItemSync } from "./adapters/kv";
 export * from "./adapters/connectivity";
 export * from "./adapters/http";
-export * from "./adapters/local-node";
+export * from "./local-node/types";
+export * from "./local-node/store";
+export * from "./local-node/security";
+export * from "./local-node/adapters";
+export * from "./local-node/service";
+// adapters/local-node is compat shim — export only non-conflicting
+export { setLocalNodeState } from "./adapters/local-node";
 export * from "./adapters/services";
 export * from "./adapters/devices";
-export { setAuthProvider, getAuthToken } from "./adapters/auth";
+export { setAuthProvider, getAuthToken, setAuthRefreshProvider, getRefreshToken, setAuthTokensProvider, setAuthTokens, setAuthClearProvider, clearAuth } from "./adapters/auth";
 export { imageCacheService } from "./adapters/image-cache";
 export * from "./adapters/business";
 export * from "./adapters/pending-orders";
 export * from "./adapters/print";
 export * from "./adapters/filesystem";
-export { KIOSK_KEYS, SELLER_ORDERS_KEYS, BUSINESS_DELIVERIES_KEYS, MENU_KEYS, REFERENCE_KEYS } from "./adapters/query-keys";
+export { SELLER_ORDERS_KEYS, BUSINESS_DELIVERIES_KEYS, MENU_KEYS, REFERENCE_KEYS } from "./adapters/query-keys";
+// KIOSK_KEYS exported from hooks/kiosk.hooks (single source)
 // POS_KEYS / SELLER_KEYS are exported from hooks/orders.hooks (offline-first source of truth)
 // ── Printer (backend-identical template) ──
 export * from "./printer/types";
@@ -91,11 +133,26 @@ export * from "./cart/store";
 export * from "./cart/hooks";
 // ── Catalog ──
 export * from "./catalog/hooks";
+// ── Order transitions (shared business logic — single source) ──
+export * from "./utils/order-transitions";
+// ── Business hours gate (single source — mirrors backend is_open?) ──
+export * from "./utils/business-hours";
+export * from "./hooks/business-hours.hooks";
+// components/OrderStatusCard was folded into order-transitions (compat re-export lives in apps)
+// ── Domain (offline-first primary DB) ──
+export * from "./domain/orders/service";
 // ── Realtime (single source — PHX WebSocket + business:{id}) ──
 export { phoenixSocket } from "./realtime/phoenix-socket";
 export { eventsService } from "./realtime/events.service";
 export { orderEventsService } from "./realtime/order-events.service";
 export { useEventsConnection } from "./realtime/useEventsConnection";
+// ── Sync jobs (POS primary sync) — debug helpers for DiagnosticsScreen
+export { getSyncJobsPendingCount, debugDumpSyncJobs, drainPending } from "./sync/sync-jobs.service";
+export { performFullSync } from "./sync/full-sync";
+export { stopHealthProbe } from "./sync/health-probe";
+export { notifyAuthChanged, subscribeAuth } from "./adapters/auth";
+// ── Session lifecycle (access-expired → refresh → refresh-expired → logout)
+export { ACCESS_EXPIRED_CODE, SESSION_DEAD_CODES, SKIP_AUTH_RETRY, extractAuthFailure, isAccessExpired, isSessionDead, hasAuthRetrySkip, refreshSession, withAuthRetry, } from "./auth/session";
 // ── Image cache (durable) ──
 export { getCachedImagePath, ensureImageCacheDir, getCachedImageInfo, cacheRemoteImage, cacheImageBatch, clearImageCache, pruneImageCache, resolveImageSource, stableCacheUrl } from "./image-cache/service";
 // ── Init helper ──
@@ -109,6 +166,8 @@ import { API_BASE_URL, WS_BASE_URL, setApiBaseUrl, setWsBaseUrl } from "./utils/
 import { SyncEngine } from "./sync/engine";
 import { restTransport } from "./sync/transport-rest";
 import { localNodeTransport } from "./sync/transport-local-node";
+import { setupSyncJobsDrain } from "./sync/sync-jobs.service";
+import { startHealthProbe } from "./sync/health-probe";
 let engine = null;
 export function createTeincCore(config = {}) {
     try {
@@ -154,6 +213,14 @@ export function createTeincCore(config = {}) {
     }
     if (config.initialConnectivity)
         setConnectivityState(config.initialConnectivity);
+    try {
+        setupSyncJobsDrain();
+    }
+    catch { }
+    try {
+        startHealthProbe();
+    }
+    catch { }
     // Debug: confirm env vars as seen by core after injection
     try {
         console.debug("[core] final URLs", { API_BASE_URL, WS_BASE_URL });

package/dist/local-node/adapters.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Local Node adapters — platform drivers implement these.
+ */
+import type { Command, DomainEvent } from "../sync/types";
+import type { ReferenceDataKey, ReferenceDataRecord } from "../reference/types";
+import type { DiscoveredNode } from "./store";
+export interface DiscoveryAdapter {
+    setOptions(opts: {
+        deviceId: string;
+        deviceName?: string;
+        onNodeFound: (node: DiscoveredNode) => void;
+        onNodeLost: (deviceId: string) => void;
+    }): void;
+    startScanning(): void;
+    stopScanning(): void;
+    startPublishing(opts: {
+        deviceId: string;
+        deviceName?: string;
+        port: number;
+        onNodeFound: (node: DiscoveredNode) => void;
+        onNodeLost: (deviceId: string) => void;
+    }): void;
+    stop(): void;
+}
+export interface LocalNodeServer {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isListening(): boolean;
+    broadcast(event: DomainEvent): void;
+}
+export interface LocalNodeClient {
+    connect(): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    execute(command: Command): Promise<DomainEvent[]>;
+    requestReferenceData(businessId: string, keys: ReferenceDataKey[]): Promise<{
+        data: Partial<Record<ReferenceDataKey, ReferenceDataRecord | null>>;
+    }>;
+    publishEvent?(event: DomainEvent): Promise<void> | void;
+}
+export interface TransportAdapter {
+    createServer(opts: {
+        port: number;
+        businessId: string;
+        secret: string;
+        onCommand: (command: Command) => Promise<DomainEvent[]>;
+        onRelayEvent: (event: DomainEvent) => void;
+        onClientConnected: (info: {
+            deviceId: string;
+            deviceName?: string;
+            host?: string;
+        }) => void;
+        onClientDisconnected: (deviceId: string) => void;
+    }): LocalNodeServer;
+    createClient(opts: {
+        node: {
+            deviceId: string;
+            host: string;
+            port: number;
+        };
+        businessId: string;
+        secret: string;
+        onEvent: (event: DomainEvent) => void;
+        onConnected: () => void;
+        onDisconnected: () => void;
+        onError: (error: unknown) => void;
+    }): LocalNodeClient;
+}
+export interface KeepAliveAdapter {
+    activate(tag: string): Promise<void>;
+    deactivate(tag: string): Promise<void>;
+}
+export interface LocalNodeDeps {
+    getDeviceId: () => string | Promise<string>;
+    getDeviceName?: () => string | undefined;
+    getBusiness: () => {
+        id: string;
+    } | null;
+    getAuth: () => {
+        user: unknown | null;
+        accessToken: string | null;
+    };
+    discovery: DiscoveryAdapter;
+    transport: TransportAdapter;
+    keepAlive?: KeepAliveAdapter;
+    cloudCommandTimeoutMs?: number;
+}

package/dist/local-node/adapters.js

@@ -0,0 +1,4 @@
+/**
+ * Local Node adapters — platform drivers implement these.
+ */
+export {};

package/dist/local-node/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./security";
+export * from "./store";
+export * from "./adapters";
+export * from "./service";

package/dist/local-node/index.js

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./security";
+export * from "./store";
+export * from "./adapters";
+export * from "./service";

package/dist/local-node/security.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Local Node security helpers — platform-agnostic.
+ *
+ * SINGLE OWNER of mesh crypto (formula + inputs). Apps (Business/Desktop/Rust)
+ * MUST NOT derive or re-implement this: core derives the secret once per
+ * business and hands the opaque value to transports. Transports only carry it.
+ *
+ * Mesh decision: the secret is business-only — `SHA256("teinc-lan:{id}:")`
+ * with a permanently empty owner segment. Same business_id ⇒ same secret on
+ * every device, regardless of which owner fields each app's store happens to
+ * carry (that variance caused `invalid_proof` between devices). The trailing
+ * colon is kept so the wire value is byte-identical to the historic formula.
+ *
+ * Pure JS WebCrypto/Node fallback so core does not depend on expo-crypto.
+ */
+/**
+ * Self-contained SHA-256 (FIPS 180-4), no platform dependency. Slower than
+ * native but handshake-rate only. Pinned by vectors in security.test.ts.
+ */
+export declare function sha256Pure(data: Uint8Array): Uint8Array;
+export declare function deriveLanSecret(business: {
+    id: string;
+}): Promise<string>;
+export declare function generateNonce(): Promise<string>;
+export declare function computeProof(secret: string, nonce: string): Promise<string>;

package/dist/local-node/security.js

@@ -0,0 +1,149 @@
+/**
+ * Local Node security helpers — platform-agnostic.
+ *
+ * SINGLE OWNER of mesh crypto (formula + inputs). Apps (Business/Desktop/Rust)
+ * MUST NOT derive or re-implement this: core derives the secret once per
+ * business and hands the opaque value to transports. Transports only carry it.
+ *
+ * Mesh decision: the secret is business-only — `SHA256("teinc-lan:{id}:")`
+ * with a permanently empty owner segment. Same business_id ⇒ same secret on
+ * every device, regardless of which owner fields each app's store happens to
+ * carry (that variance caused `invalid_proof` between devices). The trailing
+ * colon is kept so the wire value is byte-identical to the historic formula.
+ *
+ * Pure JS WebCrypto/Node fallback so core does not depend on expo-crypto.
+ */
+const LAN_SECRET_SALT = "teinc-lan";
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+function hexToBytes(hex) {
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    return out;
+}
+async function sha256Hex(input) {
+    const data = new TextEncoder().encode(input);
+    // 1) WebCrypto (RN Hermes may expose global crypto.subtle, Tauri does)
+    try {
+        const g = globalThis;
+        const subtle = g?.crypto?.subtle;
+        if (subtle) {
+            const buf = await subtle.digest("SHA-256", data);
+            return bytesToHex(new Uint8Array(buf));
+        }
+    }
+    catch { }
+    // 2) Node crypto (tests / desktop node)
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const nodeCrypto = require("crypto");
+        if (nodeCrypto?.createHash)
+            return nodeCrypto.createHash("sha256").update(data).digest("hex");
+    }
+    catch { }
+    // 3) Pure-JS SHA-256 (Hermes/RN has neither subtle nor node crypto).
+    // MUST be real SHA-256 — proofs must verify cross-platform, and the old
+    // DJB placeholder produced zero-padded non-hashes that silently failed
+    // every handshake. No app action needed: identical output everywhere.
+    return bytesToHex(sha256Pure(data));
+}
+/**
+ * Self-contained SHA-256 (FIPS 180-4), no platform dependency. Slower than
+ * native but handshake-rate only. Pinned by vectors in security.test.ts.
+ */
+export function sha256Pure(data) {
+    const K = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    ];
+    let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a;
+    let h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
+    const bitLen = data.length * 8;
+    const paddedLen = (((data.length + 8) >> 6) + 1) << 6;
+    const msg = new Uint8Array(paddedLen);
+    msg.set(data);
+    msg[data.length] = 0x80;
+    const dv = new DataView(msg.buffer);
+    dv.setUint32(paddedLen - 4, bitLen >>> 0, false);
+    dv.setUint32(paddedLen - 8, Math.floor(bitLen / 0x100000000), false);
+    const w = new Int32Array(64);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let off = 0; off < paddedLen; off += 64) {
+        for (let i = 0; i < 16; i++)
+            w[i] = dv.getInt32(off + i * 4, false);
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) | 0;
+        }
+        let [a, b, c, d, e, f, g, h] = [h0, h1, h2, h3, h4, h5, h6, h7];
+        for (let i = 0; i < 64; i++) {
+            const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (h + S1 + ch + K[i] + w[i]) | 0;
+            const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) | 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) | 0;
+        }
+        h0 = (h0 + a) | 0;
+        h1 = (h1 + b) | 0;
+        h2 = (h2 + c) | 0;
+        h3 = (h3 + d) | 0;
+        h4 = (h4 + e) | 0;
+        h5 = (h5 + f) | 0;
+        h6 = (h6 + g) | 0;
+        h7 = (h7 + h) | 0;
+    }
+    const out = new Uint8Array(32);
+    const odv = new DataView(out.buffer);
+    [h0, h1, h2, h3, h4, h5, h6, h7].forEach((v, i) => odv.setInt32(i * 4, v, false));
+    return out;
+}
+export async function deriveLanSecret(business) {
+    return sha256Hex(`${LAN_SECRET_SALT}:${business.id}:`);
+}
+export async function generateNonce() {
+    try {
+        const g = globalThis;
+        const cryptoObj = g?.crypto;
+        if (cryptoObj?.getRandomValues) {
+            const b = new Uint8Array(16);
+            cryptoObj.getRandomValues(b);
+            return bytesToHex(b);
+        }
+    }
+    catch { }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const nodeCrypto = require("crypto");
+        if (nodeCrypto?.randomBytes)
+            return bytesToHex(nodeCrypto.randomBytes(16));
+    }
+    catch { }
+    // fallback Math.random
+    const b = new Uint8Array(16);
+    for (let i = 0; i < 16; i++)
+        b[i] = Math.floor(Math.random() * 256);
+    return bytesToHex(b);
+}
+export async function computeProof(secret, nonce) {
+    return sha256Hex(`${nonce}:${secret}`);
+}

package/dist/local-node/service.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Local Node Service — mesh, no elected, every isLocalNodeEnabled device is both server and client.
+ */
+import type { Command, DomainEvent } from "../sync/types";
+import type { LocalNodeInfo } from "./types";
+import type { LocalNodeDeps, LocalNodeClient } from "./adapters";
+import type { ReferenceDataKey } from "../reference/types";
+declare class LocalNodeServiceCore {
+    private server;
+    private peers;
+    private peerInfos;
+    private mode;
+    private businessId;
+    private secret;
+    private subscribed;
+    private cachedDeviceId;
+    private lifecyclePromise;
+    private starting;
+    private deps;
+    /** mDNS publish state — a failed publish must never abort discovery. */
+    private published;
+    /** Whether discovery scanning was successfully started. */
+    private discovering;
+    init(deps: LocalNodeDeps): void;
+    private getDeps;
+    private getDeviceId;
+    private runLifecycle;
+    private runInitialize;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    reconnectNow(): void;
+    private runShutdown;
+    isLocalNode(): boolean;
+    isConnectedToNode(): boolean;
+    /** Mesh legibility for Diagnostics screens: publish/scan state per leg. */
+    getMeshStatus(): {
+        mode: string;
+        listening: boolean;
+        published: boolean;
+        discovering: boolean;
+        peers: number;
+    };
+    getClient(): LocalNodeClient | null;
+    getElectedNode(): LocalNodeInfo | null;
+    broadcastToClients(event: DomainEvent): void;
+    private storeUnsub;
+    private setupStoreSubscriptions;
+    private teardownStoreSubscriptions;
+    private startAsNode;
+    /**
+     * (Re)publish this node's mDNS advertisement. Isolated from server bring-up
+     * and discovery: a publish throw must never abort scanning, sweeping, or
+     * peer dials. Safe to call repeatedly (drivers dedupe internally).
+     */
+    private ensurePublished;
+    private startDiscovery;
+    /** Start scanning if not already running (idempotent drivers ignore repeats). */
+    private ensureDiscovery;
+    private dialInFlight;
+    private dialTimers;
+    private sweepTimer;
+    /** deviceId -> timestamp of last business_mismatch rejection. Foreign-business
+     * peers (test rigs, neighboring shops) would otherwise be redialed on every
+     * discovery event; back off quietly and re-probe after the window. */
+    private mismatchBackoff;
+    private static readonly MISMATCH_BACKOFF_MS;
+    private startPeerSweep;
+    private stopPeerSweep;
+    private connectToPeer;
+    private settleDial;
+    handleNodeCommand(command: Command): Promise<DomainEvent | null>;
+    requestReferenceData(businessId: string, keys: ReferenceDataKey[]): Promise<Partial<Record<ReferenceDataKey, import("../reference/types").ReferenceDataRecord | null>> | null>;
+    getState(): {
+        isLocalNode: boolean;
+        isConnectedToNode: boolean;
+        electedNode: LocalNodeInfo | null;
+        client: LocalNodeClient | null;
+    };
+}
+export declare const localNodeService: LocalNodeServiceCore;
+export declare function initLocalNodeService(deps: LocalNodeDeps): LocalNodeServiceCore;
+export type LocalNodeService = LocalNodeServiceCore;
+export {};