@teincfood/core 0.1.0

package/dist/sync/order-snapshots.service.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Durable order read-model.
+ *
+ * Bridges order events and fetched order lists into the SQLite
+ * `entity_snapshots` read model so a restaurant can see current + recent
+ * orders offline (survives restart and logout) and refresh them once a
+ * connection is re-established.
+ *
+ * Two sources feed the read model:
+ *   1. Incoming order/delivery events (cloud WebSocket or LAN relay) are
+ *      persisted to the events journal and used to patch the latest status of
+ *      a known order.
+ *   2. Successful order list fetches are written through as snapshots so the
+ *      exact list last seen while online is available offline.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderSnapshotsService = void 0;
+const connection_1 = require("../db/connection");
+const operations_1 = require("../db/operations");
+const sync_logger_1 = require("../utils/sync-logger");
+const RETAIN_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+const ORDER_EVENT_TYPES = new Set([
+    "order.created",
+    "order.status_changed",
+    "delivery.assigned",
+    "delivery.status_changed",
+    "delivery.pickup_confirmed",
+    "payment.completed",
+    "payment.failed",
+]);
+class OrderSnapshotsService {
+    /**
+     * Persist an order/delivery event into the durable event journal and patch
+     * the read model. Returns true if it was an order event (idempotent for
+     * duplicates).
+     */
+    async persistOrderEvent(event, origin) {
+        if (!ORDER_EVENT_TYPES.has(event.event_type))
+            return false;
+        try {
+            const db = await (0, connection_1.openSyncDatabase)();
+            await (0, operations_1.insertEvent)(db, { event, origin });
+            await this.applyOrderStatusToReadModel(db, event);
+            return true;
+        }
+        catch (error) {
+            sync_logger_1.syncLogger.error("OrderSnapshots", "Failed to persist order event", {
+                error: String(error),
+                event_type: event.event_type,
+            });
+            return false;
+        }
+    }
+    /**
+     * Patch the latest status of a known order inside every list snapshot for the
+     * business, so offline devices see live status changes without a refetch.
+     */
+    async applyOrderStatusToReadModel(db, event) {
+        const payload = event.payload;
+        const orderId = payload?.order_id;
+        const toStatus = payload?.to_status ??
+            payload?.status;
+        if (!orderId || !toStatus || event.event_type !== "order.status_changed") {
+            return;
+        }
+        try {
+            const lists = await (0, operations_1.getEntitySnapshotsByType)(db, "seller_orders");
+            for (const list of lists) {
+                const data = list.payload.data ?? [];
+                const idx = data.findIndex((o) => o.id === orderId);
+                if (idx === -1)
+                    continue;
+                const updated = data.map((o, i) => i === idx ? { ...o, status: toStatus } : o);
+                await (0, operations_1.upsertEntitySnapshot)(db, {
+                    entityType: "seller_orders",
+                    entityId: list.entity_id,
+                    businessId: list.business_id,
+                    lastEventId: event.event_id,
+                    lastEventTimestamp: event.timestamp,
+                    payload: { ...list.payload, data: updated },
+                });
+            }
+        }
+        catch (error) {
+            sync_logger_1.syncLogger.error("OrderSnapshots", "Failed to apply status to read model", {
+                error: String(error),
+            });
+        }
+    }
+    /**
+     * Write through a fetched order list so it is available offline. Used by the
+     * seller and POS order queries. `scope` distinguishes complementary lists
+     * (e.g. the unfiltered recent list) within a business.
+     */
+    async persistSellerOrders(businessId, scope, orders) {
+        if (!businessId)
+            return;
+        try {
+            const db = await (0, connection_1.openSyncDatabase)();
+            await (0, operations_1.upsertEntitySnapshot)(db, {
+                entityType: "seller_orders",
+                entityId: scope,
+                businessId,
+                lastEventId: `fetch-${Date.now()}`,
+                lastEventTimestamp: new Date().toISOString(),
+                payload: { data: orders, savedAt: new Date().toISOString() },
+            });
+        }
+        catch (error) {
+            sync_logger_1.syncLogger.error("OrderSnapshots", "Failed to persist seller list", {
+                error: String(error),
+                businessId,
+            });
+        }
+    }
+    /**
+     * Read a persisted order list from the offline read model.
+     */
+    async getSellerList(businessId, scope) {
+        try {
+            const db = await (0, connection_1.openSyncDatabase)();
+            const snap = await (0, operations_1.getEntitySnapshot)(db, "seller_orders", scope);
+            if (!snap || snap.business_id !== businessId)
+                return null;
+            return snap.payload.data ?? null;
+        }
+        catch (error) {
+            sync_logger_1.syncLogger.error("OrderSnapshots", "Failed to read seller list", {
+                error: String(error),
+            });
+            return null;
+        }
+    }
+    /**
+     * Prune snapshots outside the retention window. Call on startup.
+     */
+    async pruneOld() {
+        try {
+            const cutoff = new Date(Date.now() - RETAIN_MS).toISOString();
+            const db = await (0, connection_1.openSyncDatabase)();
+            await (0, operations_1.pruneEntitySnapshots)(db, "seller_orders", cutoff);
+        }
+        catch (error) {
+            sync_logger_1.syncLogger.error("OrderSnapshots", "Failed to prune", {
+                error: String(error),
+            });
+        }
+    }
+}
+exports.orderSnapshotsService = new OrderSnapshotsService();

package/dist/sync/pending-orders.service.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Pending Orders Service.
+ *
+ * Bridges optimistic order events (queued while offline) into the
+ * Pending Orders Store so every terminal can render them, and cleans them up
+ * once the cloud acknowledges the order.
+ *
+ * Event sources:
+ *   - The Sync Engine broadcasts `order.create_queued` events locally.
+ *   - The Local Node broadcasts the same events to LAN clients.
+ *   - The cloud returns `order.created` (echoing `local_order_number`).
+ *
+ * The optimistic event payload for `order.create_queued` is the SellerOrder
+ * itself; `order.created` carries `local_order_number` matching the optimistic
+ * order's `order_number`.
+ */
+import type { DomainEvent } from "./types";
+/**
+ * Register a callback used to invalidate TanStack Query caches when a pending
+ * order is reconciled. Returns an unregister function.
+ */
+export declare function registerPendingOrdersInvalidator(fn: () => void): () => void;
+/**
+ * Load persisted unsynced order:create_queued events into the store.
+ * Idempotent; safe to call after app restart while still offline.
+ */
+export declare function hydratePendingOrders(): Promise<void>;
+/**
+ * Apply a domain event to the pending-orders store and persistence layer.
+ *
+ *   - order.create_queued → add to store + persist (origin local|lan).
+ *   - order.created       → remove matching pending order, mark the persisted
+ *                           optimistic event synced, and invalidate caches.
+ *
+ * Idempotent: duplicate events (local broadcast + LAN broadcast + direct
+ * enqueue) are safe.
+ */
+/**
+ * Apply an order/delivery state-change event: refresh order caches so every
+ * terminal shows the same order states. Status changes are not stored in the
+ * pending-orders store (only queued creations are); this only fires the
+ * invalidator. Idempotent — duplicate deliveries are harmless.
+ */
+export declare function applyOrderStateChangeEvent(event: DomainEvent, origin?: "local" | "lan"): Promise<void>;
+export declare function applyPendingOrderEvent(event: DomainEvent, origin?: "local" | "lan"): Promise<void>;

package/dist/sync/pending-orders.service.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * Pending Orders Service.
+ *
+ * Bridges optimistic order events (queued while offline) into the
+ * Pending Orders Store so every terminal can render them, and cleans them up
+ * once the cloud acknowledges the order.
+ *
+ * Event sources:
+ *   - The Sync Engine broadcasts `order.create_queued` events locally.
+ *   - The Local Node broadcasts the same events to LAN clients.
+ *   - The cloud returns `order.created` (echoing `local_order_number`).
+ *
+ * The optimistic event payload for `order.create_queued` is the SellerOrder
+ * itself; `order.created` carries `local_order_number` matching the optimistic
+ * order's `order_number`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPendingOrdersInvalidator = registerPendingOrdersInvalidator;
+exports.hydratePendingOrders = hydratePendingOrders;
+exports.applyOrderStateChangeEvent = applyOrderStateChangeEvent;
+exports.applyPendingOrderEvent = applyPendingOrderEvent;
+const connection_1 = require("../db/connection");
+const operations_1 = require("../db/operations");
+const pending_orders_1 = require("../adapters/pending-orders");
+const order_snapshots_service_1 = require("./order-snapshots.service");
+const sync_logger_1 = require("../utils/sync-logger");
+const PENDING_EVENT_TYPE = "order.create_queued";
+/** Order/delivery state-change events that should refresh every terminal. */
+const ORDER_STATE_EVENT_TYPES = new Set([
+    "order.status_changed",
+    "delivery.status_changed",
+    "delivery.assigned",
+]);
+let invalidator = null;
+/**
+ * Register a callback used to invalidate TanStack Query caches when a pending
+ * order is reconciled. Returns an unregister function.
+ */
+function registerPendingOrdersInvalidator(fn) {
+    invalidator = fn;
+    return () => {
+        if (invalidator === fn)
+            invalidator = null;
+    };
+}
+/**
+ * Load persisted unsynced order:create_queued events into the store.
+ * Idempotent; safe to call after app restart while still offline.
+ */
+async function hydratePendingOrders() {
+    const store = pending_orders_1.usePendingOrdersStore.getState();
+    if (store.hydrated)
+        return;
+    try {
+        const db = await (0, connection_1.openSyncDatabase)();
+        const byNumber = new Map();
+        for (const origin of ["local", "lan"]) {
+            const events = await (0, operations_1.getUnsyncedEvents)(db, origin, Number.MAX_SAFE_INTEGER);
+            for (const event of events) {
+                if (event.event_type !== PENDING_EVENT_TYPE)
+                    continue;
+                const order = event.payload;
+                if (order?.order_number)
+                    byNumber.set(order.order_number, order);
+            }
+        }
+        pending_orders_1.usePendingOrdersStore.setState({ orders: [...byNumber.values()] });
+    }
+    catch (error) {
+        sync_logger_1.syncLogger.error("PendingOrders", "Hydration failed", {
+            error: String(error),
+        });
+    }
+    finally {
+        pending_orders_1.usePendingOrdersStore.getState().setHydrated(true);
+    }
+}
+/**
+ * Apply a domain event to the pending-orders store and persistence layer.
+ *
+ *   - order.create_queued → add to store + persist (origin local|lan).
+ *   - order.created       → remove matching pending order, mark the persisted
+ *                           optimistic event synced, and invalidate caches.
+ *
+ * Idempotent: duplicate events (local broadcast + LAN broadcast + direct
+ * enqueue) are safe.
+ */
+/**
+ * Apply an order/delivery state-change event: refresh order caches so every
+ * terminal shows the same order states. Status changes are not stored in the
+ * pending-orders store (only queued creations are); this only fires the
+ * invalidator. Idempotent — duplicate deliveries are harmless.
+ */
+async function applyOrderStateChangeEvent(event, origin = "local") {
+    try {
+        if (!ORDER_STATE_EVENT_TYPES.has(event.event_type))
+            return;
+        sync_logger_1.syncLogger.debug("OrderState", "Order state changed", {
+            origin,
+            event_type: event.event_type,
+            entity_id: event.entity_id,
+        });
+        // Persist the event into the durable journal and patch the offline read
+        // model so every terminal keeps the same order states after a restart.
+        await order_snapshots_service_1.orderSnapshotsService.persistOrderEvent(event, origin);
+        invalidator?.();
+    }
+    catch (error) {
+        sync_logger_1.syncLogger.error("OrderState", "Failed to apply order state change", {
+            error: String(error),
+            event_type: event.event_type,
+        });
+    }
+}
+async function applyPendingOrderEvent(event, origin = "local") {
+    try {
+        if (event.event_type === PENDING_EVENT_TYPE) {
+            const order = event.payload;
+            if (!order?.order_number)
+                return;
+            pending_orders_1.usePendingOrdersStore.getState().addOrder(order);
+            const db = await (0, connection_1.openSyncDatabase)();
+            await (0, operations_1.insertEvent)(db, { event, origin });
+            return;
+        }
+        if (event.event_type === "order.created") {
+            const payload = event.payload;
+            const localOrderNumber = payload?.local_order_number;
+            if (typeof localOrderNumber !== "string")
+                return;
+            pending_orders_1.usePendingOrdersStore.getState().removeByOrderNumber(localOrderNumber);
+            // Persist the cloud acknowledgment into the durable journal + read model.
+            await order_snapshots_service_1.orderSnapshotsService.persistOrderEvent(event, "cloud");
+            const db = await (0, connection_1.openSyncDatabase)();
+            // Mark every persisted optimistic event for this local order number as
+            // synced so it does not rehydrate as pending after a restart. Check both
+            // origins: the creating terminal persisted "local", LAN clients "lan".
+            const ids = [];
+            for (const origin of ["local", "lan"]) {
+                const unsynced = await (0, operations_1.getUnsyncedEvents)(db, origin, Number.MAX_SAFE_INTEGER);
+                for (const e of unsynced) {
+                    if (e.event_type !== PENDING_EVENT_TYPE)
+                        continue;
+                    if (e.payload?.order_number ===
+                        localOrderNumber) {
+                        ids.push(e.event_id);
+                    }
+                }
+            }
+            if (ids.length > 0) {
+                await (0, operations_1.markEventsSynced)(db, ids);
+            }
+            invalidator?.();
+        }
+    }
+    catch (error) {
+        sync_logger_1.syncLogger.error("PendingOrders", "Failed to apply event", {
+            error: String(error),
+            event_type: event.event_type,
+        });
+    }
+}

package/dist/sync/transport-local-node.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Local Node Transport.
+ *
+ * Routes commands to the elected Local Node over the LAN and receives events
+ * broadcast by the Local Node.
+ */
+import type { Command, DomainEvent, Transport } from "./types";
+export declare class LocalNodeTransport implements Transport {
+    readonly name = "local_node";
+    isAvailable(): boolean;
+    subscribe(): () => void;
+    execute(command: Command): Promise<DomainEvent[]>;
+}
+export declare const localNodeTransport: LocalNodeTransport;

package/dist/sync/transport-local-node.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Local Node Transport.
+ *
+ * Routes commands to the elected Local Node over the LAN and receives events
+ * broadcast by the Local Node.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localNodeTransport = exports.LocalNodeTransport = void 0;
+const local_node_1 = require("../adapters/local-node");
+const sync_logger_1 = require("../utils/sync-logger");
+class LocalNodeTransport {
+    constructor() {
+        this.name = "local_node";
+    }
+    isAvailable() {
+        const store = local_node_1.useLocalNodeStore.getState();
+        if (!store.isLocalNodeEnabled)
+            return false;
+        // If this device is the Local Node, it is always available.
+        if (local_node_1.localNodeService.isLocalNode())
+            return true;
+        // Otherwise, we must be connected to the elected node.
+        return local_node_1.localNodeService.isConnectedToNode();
+    }
+    subscribe() {
+        // Events are received through the LocalNodeService event pipeline.
+        return () => undefined;
+    }
+    async execute(command) {
+        sync_logger_1.syncLogger.transport(this, "executing", {
+            command_type: command.command_type,
+            command_id: command.command_id,
+        });
+        if (local_node_1.localNodeService.isLocalNode()) {
+            // This device is the Local Node: execute locally.
+            sync_logger_1.syncLogger.info("LocalNodeTransport", "Executing on local node (self)", {
+                command_type: command.command_type,
+                command_id: command.command_id,
+            });
+            const event = await local_node_1.localNodeService.handleNodeCommand(command);
+            sync_logger_1.syncLogger.transport(this, "completed", {
+                command_type: command.command_type,
+                event_type: event?.event_type,
+            });
+            return event ? [event] : [];
+        }
+        // Client: send command to the Local Node.
+        const client = local_node_1.localNodeService.getClient();
+        if (!client) {
+            throw new Error("LocalNodeTransport: no client connected to Local Node");
+        }
+        sync_logger_1.syncLogger.info("LocalNodeTransport", "Sending command to Local Node", {
+            command_type: command.command_type,
+            command_id: command.command_id,
+            node_device_id: local_node_1.localNodeService.getElectedNode()?.deviceId,
+        });
+        const events = await client.execute(command);
+        sync_logger_1.syncLogger.transport(this, "completed", {
+            command_type: command.command_type,
+            event_count: events.length,
+        });
+        return events;
+    }
+}
+exports.LocalNodeTransport = LocalNodeTransport;
+exports.localNodeTransport = new LocalNodeTransport();

package/dist/sync/transport-rest.d.ts

@@ -0,0 +1,17 @@
+/**
+ * REST transport implementation.
+ *
+ * Translates domain commands into existing service calls and returns the
+ * resulting domain events. This transport is used when the cloud API is
+ * reachable.
+ */
+import type { Command, DomainEvent, Transport } from "./types";
+export declare class RestTransport implements Transport {
+    readonly name = "rest";
+    isAvailable(): boolean;
+    subscribe(): () => void;
+    execute(command: Command): Promise<DomainEvent[]>;
+    private dispatchCommand;
+    private wrapResponse;
+}
+export declare const restTransport: RestTransport;

package/dist/sync/transport-rest.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * REST transport implementation.
+ *
+ * Translates domain commands into existing service calls and returns the
+ * resulting domain events. This transport is used when the cloud API is
+ * reachable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restTransport = exports.RestTransport = void 0;
+const services_1 = require("../adapters/services");
+const sync_logger_1 = require("../utils/sync-logger");
+const uuid_1 = require("../utils/uuid");
+class RestTransport {
+    constructor() {
+        this.name = "rest";
+    }
+    isAvailable() {
+        // Availability is determined by the Sync Engine based on connectivity.
+        return true;
+    }
+    subscribe() {
+        // Events from the cloud arrive via Phoenix Channels, not push replies.
+        // This transport does not push events itself.
+        return () => undefined;
+    }
+    async execute(command) {
+        sync_logger_1.syncLogger.transport(this, "executing", {
+            command_type: command.command_type,
+            command_id: command.command_id,
+        });
+        try {
+            const event = await this.dispatchCommand(command);
+            sync_logger_1.syncLogger.transport(this, "completed", {
+                command_type: command.command_type,
+                event_type: event?.event_type,
+            });
+            return event ? [event] : [];
+        }
+        catch (error) {
+            sync_logger_1.syncLogger.transport(this, "error", {
+                command_type: command.command_type,
+                command_id: command.command_id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async dispatchCommand(command) {
+        const { command_type, business_id, entity_id, payload } = command;
+        const timestamp = new Date().toISOString();
+        switch (command_type) {
+            case "order:create": {
+                const posPayload = {
+                    ...payload,
+                    command_id: command.command_id,
+                    local_order_number: payload.order_number,
+                };
+                const response = await services_1.posService.createPOSOrder(business_id, posPayload);
+                return this.wrapResponse("order.created", response.data, entity_id, timestamp, command);
+            }
+            case "order:accept": {
+                const response = await services_1.sellerService.acceptOrder(entity_id);
+                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+            }
+            case "order:reject": {
+                const response = await services_1.sellerService.rejectOrder(entity_id);
+                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+            }
+            case "order:start_preparing": {
+                const response = await services_1.sellerService.startPreparingOrder(entity_id);
+                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+            }
+            case "order:mark_ready": {
+                const response = await services_1.sellerService.markOrderReady(entity_id);
+                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+            }
+            case "order:complete_pickup": {
+                const response = await services_1.sellerService.completeOrderPickup(entity_id);
+                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+            }
+            case "order:cancel": {
+                const response = await services_1.sellerService.cancelOrder(entity_id);
+                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+            }
+            case "delivery:assign": {
+                const response = await services_1.kioskService.assignKioskOrderToRider(entity_id, payload.rider_id);
+                return this.wrapResponse("delivery.assigned", response, entity_id, timestamp, command);
+            }
+            case "delivery:confirm_handover": {
+                const response = await services_1.sellerService.confirmHandover(entity_id);
+                return this.wrapResponse("delivery.status_changed", response, entity_id, timestamp, command);
+            }
+            default:
+                throw new Error(`RestTransport: unsupported command type ${command_type}`);
+        }
+    }
+    wrapResponse(eventType, data, entityId, timestamp, command) {
+        return {
+            event_id: (0, uuid_1.generateEventId)(),
+            event_type: eventType,
+            event_version: "1.0",
+            entity_id: entityId ?? command.entity_id ?? data.id ?? "unknown",
+            user_id: command.user_id,
+            device_id: command.device_id,
+            payload: data,
+            timestamp,
+        };
+    }
+}
+exports.RestTransport = RestTransport;
+exports.restTransport = new RestTransport();

package/dist/sync/types.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Core types for the offline-first, event-driven Sync Engine.
+ *
+ * These types define the contract between:
+ *   - UI / Hooks
+ *   - Repositories
+ *   - Sync Engine
+ *   - Transports (REST, Local Node, queued)
+ *
+ * All timestamps are ISO strings. Monetary amounts remain in minor units.
+ */
+export interface EventMetadata {
+    /** Globally unique event identifier (UUID v4). */
+    event_id: string;
+    /** Business event type, e.g. "order.created". */
+    event_type: string;
+    /** Event schema version, e.g. "1.0". */
+    event_version: string;
+    /** ISO 8601 timestamp when the event was originally emitted. */
+    timestamp: string;
+    /** Device that produced the event. */
+    device_id: string;
+    /** User that triggered the event. */
+    user_id: string;
+    /** ID of the aggregate/entity the event belongs to. */
+    entity_id: string;
+}
+export interface DomainEvent<T = unknown> extends EventMetadata {
+    payload: T;
+}
+export interface CommandMetadata {
+    /** Globally unique command identifier (UUID v4). Used for idempotency. */
+    command_id: string;
+    /** Command type, e.g. "create_order". */
+    command_type: string;
+    /** Command schema version, e.g. "1.0". */
+    command_version: string;
+    /** ISO 8601 timestamp when the command was issued. */
+    timestamp: string;
+    /** Device that issued the command. */
+    device_id: string;
+    /** User that issued the command. */
+    user_id: string;
+    /** Business that owns the command. */
+    business_id: string;
+    /** Aggregate/entity ID the command targets, when applicable. */
+    entity_id?: string;
+}
+export interface Command<T = unknown> extends CommandMetadata {
+    payload: T;
+}
+export type CommandStatus = "pending" | "in_flight" | "completed" | "failed" | "cancelled";
+export interface PersistedCommand<T = Record<string, unknown>> extends Command<T> {
+    /** Local database row ID. */
+    id: number;
+    status: CommandStatus;
+    /** Error message if status === "failed". */
+    error?: string | null;
+    /** Retry count. */
+    retry_count: number;
+    /** ISO 8601 timestamp of last retry attempt. */
+    last_attempted_at?: string | null;
+    /** ISO 8601 timestamp when the command was persisted. */
+    created_at: string;
+    /** ISO 8601 timestamp when the command was last updated. */
+    updated_at: string;
+}
+export interface PersistedEvent<T = Record<string, unknown>> extends DomainEvent<T> {
+    /** Local database row ID. */
+    id: number;
+    /** Whether this event originated locally or from cloud/LAN. */
+    origin: "local" | "cloud" | "lan";
+    /** Whether the event has been synced to the cloud. */
+    synced_to_cloud: boolean;
+    /** ISO 8601 timestamp when the event was persisted. */
+    persisted_at: string;
+}
+export interface Transport {
+    /** Human-readable transport name for logging. */
+    readonly name: string;
+    /** True if the transport is currently available to accept commands. */
+    isAvailable(): boolean;
+    /**
+     * Execute a command and return resulting domain events.
+     * The transport is responsible for network serialization only.
+     */
+    execute(command: Command): Promise<DomainEvent[]>;
+    /**
+     * Subscribe to events pushed by the transport.
+     * Returns an unsubscribe function.
+     */
+    subscribe(handler: (event: DomainEvent) => void): () => void;
+}
+export interface SyncStrategy {
+    /** Decide how a command should be handled given current state. */
+    resolve(command: Command, context: {
+        isOnline: boolean;
+        isCloudReachable: boolean;
+        isLocalNodeAvailable: boolean;
+        queueDepth: number;
+    }): "cloud" | "local_node" | "queue" | "reject";
+}