@totemsdk/omnia-host 0.9.0 → 0.11.0

package/dist/lifecycle.js

@@ -1,13 +1,25 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOmniaHost = createOmniaHost;
+const node_path_1 = __importDefault(require("node:path"));
+const bus_js_1 = require("./observe/bus.js");
+const emitter_js_1 = require("./observe/emitter.js");
+const store_js_1 = require("./observe/store.js");
+const snapshot_js_1 = require("./observe/snapshot.js");
 const omnia_1 = require("@totemsdk/omnia");
 const sqlite_store_js_1 = require("./stores/sqlite-store.js");
 const operations_js_1 = require("./stores/operations.js");
 const jsonrpc_js_1 = require("./api/jsonrpc.js");
 const totem_node_adapter_js_1 = require("./chain/totem-node-adapter.js");
 const routing_provider_js_1 = require("./router/routing-provider.js");
+const p2p_hub_1 = require("@totemsdk/p2p-hub");
 const methods_js_1 = require("./api/methods.js");
+const reply_cache_js_1 = require("./reply-cache.js");
+const omnia_factory_1 = require("@totemsdk/omnia-factory");
+const omnia_splice_1 = require("@totemsdk/omnia-splice");
 /**
  * Phase-1 lifecycle shell. Subsystems will be attached in later phases while
  * preserving idempotent startup and shutdown for the CLI and embedding users.
@@ -23,9 +35,15 @@ function createOmniaHost(config, dependencies = {}) {
         : undefined;
     const injectedOperationStore = dependencies.operationStore;
     let ownedOperationStore;
+    let observationStore = dependencies.observationStore;
+    let ownedObservationStore;
+    const observationBus = dependencies.observationBus ?? new bus_js_1.ObservationBus();
+    let observation;
     let controlServer = dependencies.controlServer;
     let chainAdapter = dependencies.chainAdapter;
     let routingProvider = dependencies.routingProvider ?? new routing_provider_js_1.InProcessRoutingProvider();
+    let p2pHubServer;
+    let p2pHubUrl;
     return {
         config,
         get swarm() {
@@ -34,6 +52,9 @@ function createOmniaHost(config, dependencies = {}) {
         get channels() {
             return channelStore;
         },
+        get p2pHubUrl() {
+            return p2pHubUrl;
+        },
         async start() {
             if (started)
                 return;
@@ -50,13 +71,46 @@ function createOmniaHost(config, dependencies = {}) {
                 ownedOperationStore = new operations_js_1.OperationStore(config.dbPath);
                 operationStore = ownedOperationStore;
             }
+            const observeEnabled = dependencies.observe === true || (dependencies.observe !== false && config.observeDisabled !== true && config.observeDbPath !== undefined);
+            if (observeEnabled && !observationStore) {
+                const observePath = config.observeDbPath ?? node_path_1.default.join(node_path_1.default.dirname(config.dbPath), 'observe.sqlite');
+                try {
+                    ownedObservationStore = await (0, store_js_1.createSqliteObservationStore)(observePath);
+                    observationStore = ownedObservationStore;
+                }
+                catch (err) {
+                    console.error('[omnia-host] observation store disabled:', err instanceof Error ? err.message : String(err));
+                }
+            }
+            if (observationStore) {
+                observation = new emitter_js_1.ObservationEmitter({
+                    store: observationStore,
+                    bus: observationBus,
+                    networkId: config.networkId ?? dependencies.networkId ?? 'omnia',
+                    sourceNodeId: config.sourceNodeId ?? dependencies.sourceNodeId ?? config.localPartyId ?? 'omnia-host',
+                });
+            }
             if (!swarm) {
                 const relay = config.relay
                     ? { mode: 'self-hosted', relayUrl: config.relay }
                     : { mode: 'native' };
+                const dhtBootstrap = (process.env.OMNIA_DHT_BOOTSTRAP ?? '')
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                // Serverless native mode: bind/announce an explicit local interface so
+                // peers can reach us directly (multi-homed hosts, netns, VPN, etc.).
+                const dhtHost = process.env.OMNIA_DHT_HOST?.trim() || undefined;
+                const dhtPort = process.env.OMNIA_DHT_PORT
+                    ? Number(process.env.OMNIA_DHT_PORT)
+                    : undefined;
                 swarm = await (dependencies.createSwarm ?? omnia_1.createOmniaSwarm)({
                     localPubkey: config.localPubkey,
                     relay,
+                    ...(dhtBootstrap.length ? { bootstrap: dhtBootstrap } : {}),
+                    ...(dependencies.transportKeyPair ? { keyPair: dependencies.transportKeyPair } : {}),
+                    ...(dhtHost ? { host: dhtHost } : {}),
+                    ...(dhtPort ? { port: dhtPort } : {}),
                 });
             }
             if (!chainAdapter) {
@@ -68,6 +122,21 @@ function createOmniaHost(config, dependencies = {}) {
                     ssl: rpc.protocol === 'https:',
                 });
             }
+            if (config.p2pHubPort !== undefined || dependencies.p2pHubNetwork) {
+                const native = swarm.nativeSwarm?.();
+                const network = dependencies.p2pHubNetwork ?? await (0, p2p_hub_1.createHyperswarmHubNetwork)(native ? { swarm: native } : {});
+                p2pHubServer = await (0, p2p_hub_1.createWebSocketHubServer)({
+                    network,
+                    host: config.p2pHubHost ?? '127.0.0.1',
+                    port: config.p2pHubPort ?? 0,
+                    ...(config.p2pHubToken ? { token: config.p2pHubToken } : {}),
+                    ...(config.p2pHubOrigins ? { allowedOrigins: config.p2pHubOrigins } : {}),
+                    ...(config.p2pHubTopics ? { allowedTopicPrefixes: config.p2pHubTopics } : {}),
+                });
+                const address = await p2pHubServer.listen();
+                const host = address.host.includes(':') ? `[${address.host}]` : address.host;
+                p2pHubUrl = `ws://${host}:${address.port}`;
+            }
             const localParticipant = dependencies.localParticipant ?? (config.localPartyId && config.localPubkey && config.localAddressIndex !== undefined
                 ? {
                     partyId: config.localPartyId,
@@ -76,11 +145,316 @@ function createOmniaHost(config, dependencies = {}) {
                     settlementAddress: config.localSettlementAddress,
                 }
                 : undefined);
+            // Factory managers default to this node's own lease bundle so the local
+            // side can propose/sign without extra wiring. A two-host factory still
+            // needs peer coordination (FACTORY_PROPOSAL/ACCEPT).
+            const factoryBundles = dependencies.factoryBundles ?? (localParticipant && dependencies.signer && dependencies.leaseProvider
+                ? {
+                    [localParticipant.partyId]: {
+                        signer: dependencies.signer,
+                        leaseProvider: dependencies.leaseProvider,
+                    },
+                }
+                : undefined);
+            const factories = dependencies.factories ?? (factoryBundles ? new Map() : undefined);
+            const localBundle = localParticipant
+                ? factoryBundles?.[localParticipant.partyId]
+                : undefined;
+            const spliceLeaseProvider = dependencies.spliceLeaseProvider ?? (dependencies.signer && dependencies.leaseProvider
+                ? {
+                    signer: dependencies.signer,
+                    wotsLease: dependencies.leaseProvider,
+                    ...(chainAdapter
+                        ? { broadcast: (txHex) => chainAdapter.broadcastTxPoW(txHex) }
+                        : {}),
+                }
+                : undefined);
+            const spliceProposals = dependencies.spliceProposals ?? new Map();
+            const spliceAcceptances = dependencies.spliceAcceptances ?? new Map();
+            const onSpliceMessage = async (peer, msg) => {
+                if (!spliceLeaseProvider || !channelStore)
+                    return;
+                if (msg?.type !== 'SPLICE_PROPOSAL' && msg?.type !== 'SPLICE_FINALIZED')
+                    return;
+                const payload = (msg.payload ?? {});
+                try {
+                    if (msg.type === 'SPLICE_PROPOSAL' && payload.proposal) {
+                        const proposal = payload.proposal;
+                        let channel = channelStore.get(proposal.channelId);
+                        if (!channel)
+                            throw new Error(`Splice channel ${proposal.channelId} not found`);
+                        const prior = spliceAcceptances.get(proposal.spliceId);
+                        if (prior) {
+                            await peer.sendMessage({
+                                type: 'SPLICE_ACCEPT',
+                                channelId: msg.channelId,
+                                nonce: msg.nonce,
+                                payload: { acceptance: prior },
+                            });
+                            return;
+                        }
+                        if (channel.status === 'active') {
+                            channel = await (0, omnia_splice_1.quiesceChannel)(channel, spliceLeaseProvider);
+                            channelStore.set(channel.channelId, channel);
+                        }
+                        const acceptance = await (0, omnia_splice_1.acceptSplice)(channel, proposal, spliceLeaseProvider);
+                        spliceAcceptances.set(proposal.spliceId, acceptance);
+                        await peer.sendMessage({
+                            type: 'SPLICE_ACCEPT',
+                            channelId: msg.channelId,
+                            nonce: msg.nonce,
+                            payload: { acceptance },
+                        });
+                        return;
+                    }
+                    if (msg.type === 'SPLICE_FINALIZED' && payload.channel) {
+                        const channel = payload.channel;
+                        channelStore.set(channel.channelId, channel);
+                        void observation?.emit({
+                            domain: 'splice', kind: 'splice.finalized', phase: 'confirmed',
+                            entity: { type: 'channel', id: channel.channelId },
+                            amounts: { capacity: channel.totalValue?.toString(), balances: Object.fromEntries(Object.entries(channel.balances ?? {}).map(([k, v]) => [k, v.toString()])) },
+                            data: { spliceId: payload.spliceId, txId: payload.txId },
+                        });
+                        const acceptance = spliceAcceptances.get(payload.spliceId);
+                        if (acceptance && typeof payload.txId === 'string') {
+                            await spliceLeaseProvider.wotsLease
+                                .commitKeyUse(acceptance.acceptorReservationId, payload.txId)
+                                .catch(() => { });
+                        }
+                    }
+                }
+                catch (err) {
+                    await peer.sendMessage({
+                        type: 'ERROR',
+                        channelId: msg.channelId,
+                        nonce: msg.nonce,
+                        payload: { error: err instanceof Error ? err.message : String(err) },
+                    }).catch(() => { });
+                }
+            };
+            const factoryReplies = new reply_cache_js_1.ReplyCache();
+            const vcReplies = new reply_cache_js_1.ReplyCache();
+            const onFactoryMessage = async (peer, msg) => {
+                if (!factories || !localBundle)
+                    return;
+                if (msg?.type !== 'FACTORY_PROPOSAL' &&
+                    msg?.type !== 'FACTORY_FUNDING_REQUEST' &&
+                    msg?.type !== 'FACTORY_CLOSE_PROPOSAL' &&
+                    msg?.type !== 'FACTORY_CLOSE_FINALIZED')
+                    return;
+                const payload = (msg?.payload ?? {});
+                if (process.env.OMNIA_DEBUG) {
+                    console.error('[factory] recv', msg.type, 'hasFactory', !!payload.factory, 'bundles', !!localBundle);
+                }
+                const key = factoryReplies.key(msg.type, msg.channelId, msg.nonce);
+                const reply = await factoryReplies.run(key, async () => {
+                    try {
+                        if (msg.type === 'FACTORY_FUNDING_REQUEST' && typeof payload.digest === 'string') {
+                            const digest = Uint8Array.from(Buffer.from(payload.digest.replace(/^0x/i, ''), 'hex'));
+                            const reservation = await localBundle.leaseProvider.reserveKeyUse({
+                                treeId: 'factory-funding',
+                                purpose: 'factory-funding',
+                                payloadHash: payload.digest,
+                            });
+                            try {
+                                const signature = await localBundle.signer.sign(digest, reservation.indices);
+                                await localBundle.leaseProvider.commitKeyUse(reservation.reservationId, 'factory-funding');
+                                return {
+                                    type: 'FACTORY_FUNDING_RESPONSE',
+                                    channelId: msg.channelId,
+                                    nonce: msg.nonce,
+                                    payload: { signature: '0x' + Buffer.from(signature).toString('hex') },
+                                };
+                            }
+                            catch (err) {
+                                await localBundle.leaseProvider.burnReservation(reservation.reservationId, 'factory-funding-failed').catch(() => { });
+                                throw err;
+                            }
+                        }
+                        if (msg.type === 'FACTORY_PROPOSAL' && payload.factory) {
+                            const accepted = await (0, omnia_factory_1.acceptFactory)(payload.factory, localBundle);
+                            factories.set(accepted.factoryId, accepted);
+                            void observation?.emit({
+                                domain: 'factory', kind: 'factory.accepted', phase: 'accepted',
+                                entity: { type: 'factory', id: accepted.factoryId },
+                                data: { participants: accepted.participants },
+                            });
+                            return {
+                                type: 'FACTORY_ACCEPT',
+                                channelId: accepted.factoryId,
+                                nonce: msg.nonce,
+                                payload: { factory: accepted },
+                            };
+                        }
+                        if (msg.type === 'FACTORY_CLOSE_PROPOSAL' && payload.factoryId) {
+                            const factory = factories.get(payload.factoryId);
+                            if (!factory)
+                                throw new Error(`Factory ${payload.factoryId} not found`);
+                            const signature = await (0, omnia_factory_1.signFactorySettlement)(factory, payload.draft, localBundle);
+                            await localBundle.leaseProvider
+                                .commitKeyUse(signature.reservationId, `factory-settlement-${payload.factoryId}`)
+                                .catch(() => { });
+                            return {
+                                type: 'FACTORY_CLOSE_ACCEPT',
+                                channelId: payload.factoryId,
+                                nonce: msg.nonce,
+                                payload: { signature },
+                            };
+                        }
+                        if (msg.type === 'FACTORY_CLOSE_FINALIZED' && payload.factoryId) {
+                            const factory = factories.get(payload.factoryId);
+                            if (factory)
+                                factories.set(payload.factoryId, { ...factory, status: 'closed' });
+                            return null;
+                        }
+                        return null;
+                    }
+                    catch (e) {
+                        if (process.env.OMNIA_DEBUG)
+                            console.error('[factory] err', String(e));
+                        return {
+                            type: 'ERROR',
+                            channelId: msg.channelId,
+                            nonce: msg.nonce,
+                            payload: { error: String(e) },
+                        };
+                    }
+                });
+                if (reply)
+                    await peer.sendMessage(reply);
+            };
+            const channelPeers = new Map();
+            const onPeerMessage = (peer, msg) => {
+                if (msg?.channelId)
+                    channelPeers.set(msg.channelId, peer);
+                void observation?.emit({
+                    domain: 'transport', kind: 'transport.message', phase: 'observed',
+                    entity: { type: 'node', id: config.sourceNodeId ?? config.localPartyId ?? 'omnia-host' },
+                    evidence: { peerPublicKeyDigest: peer?.publicKeyDigest },
+                    data: { type: msg?.type, channelId: msg?.channelId, nonce: msg?.nonce },
+                });
+            };
+            const onChannelAccepted = (channel, peer) => {
+                void observation?.emit({
+                    domain: 'channel', kind: 'channel.proposal.accepted', phase: 'accepted',
+                    entity: { type: 'channel', id: channel.channelId },
+                    parties: { local: localParticipant?.partyId, remote: channel.parties?.find((p) => p.partyId !== localParticipant?.partyId)?.partyId },
+                    token: { tokenId: channel.tokenId, scale: channel.tokenScale ?? 0 },
+                    amounts: { capacity: channel.totalValue?.toString(), balances: Object.fromEntries(Object.entries(channel.balances ?? {}).map(([k, v]) => [k, v.toString()])) },
+                    transitionHash: (0, emitter_js_1.channelTransitionHash)(channel),
+                    evidence: { peerPublicKeyDigest: peer?.publicKeyDigest },
+                });
+            };
+            const onStateUpdated = (channel, peer) => {
+                void observation?.emit({
+                    domain: 'channel', kind: 'channel.updated', phase: 'committed',
+                    entity: { type: 'channel', id: channel.channelId },
+                    parties: { local: localParticipant?.partyId, remote: channel.parties?.find((p) => p.partyId !== localParticipant?.partyId)?.partyId },
+                    token: { tokenId: channel.tokenId, scale: channel.tokenScale ?? 0 },
+                    after: { sequence: channel.currentSequence, balances: Object.fromEntries(Object.entries(channel.balances ?? {}).map(([k, v]) => [k, v.toString()])) },
+                    transitionHash: (0, emitter_js_1.channelTransitionHash)(channel),
+                    evidence: { peerPublicKeyDigest: peer?.publicKeyDigest },
+                });
+            };
+            const onSettlementProposed = (payload, peer) => {
+                void observation?.emit({
+                    domain: 'settlement', kind: 'settlement.proposed', phase: 'proposed',
+                    entity: { type: 'channel', id: payload?.channelId ?? 'unknown' },
+                    evidence: { peerPublicKeyDigest: peer?.publicKeyDigest },
+                    data: { payload },
+                });
+            };
+            const onVcMessage = async (peer, msg) => {
+                if (!factories || !localBundle)
+                    return;
+                const payload = (msg?.payload ?? {});
+                if (msg?.type === 'VC_FINALIZED') {
+                    if (payload.factory)
+                        factories.set(payload.factory.factoryId, payload.factory);
+                    if (payload.kind === 'vc-open' && payload.channel) {
+                        channelStore?.set(payload.channel.channelId, payload.channel);
+                        void observation?.emit({
+                            domain: 'factory', kind: 'factory.vc_opened', phase: 'accepted',
+                            entity: { type: 'channel', id: payload.channel.channelId },
+                            data: { factoryId: payload.factory?.factoryId },
+                        });
+                    }
+                    else if (payload.kind === 'vc-close' && payload.channelId) {
+                        channelStore?.delete(payload.channelId);
+                        void observation?.emit({
+                            domain: 'factory', kind: 'factory.vc_closed', phase: 'closed',
+                            entity: { type: 'channel', id: payload.channelId },
+                            data: { factoryId: payload.factory?.factoryId },
+                        });
+                    }
+                    return;
+                }
+                if (msg?.type !== 'VC_PROPOSAL')
+                    return;
+                const key = vcReplies.key(msg.type, msg.channelId, msg.nonce, payload.kind);
+                const reply = await vcReplies.run(key, async () => {
+                    try {
+                        const factory = factories.get(payload.factoryId);
+                        if (!factory)
+                            throw new Error(`Factory ${payload.factoryId} not found`);
+                        if (payload.kind === 'vc-open') {
+                            const signature = await (0, omnia_factory_1.signVirtualChannelOpen)(factory, payload.plan, localBundle);
+                            await localBundle.leaseProvider.commitKeyUse(signature.reservationId, `factory-vc-open-${payload.factoryId}`);
+                            return {
+                                type: 'VC_ACCEPT',
+                                channelId: payload.vcId,
+                                nonce: msg.nonce,
+                                payload: { kind: 'vc-open', signature },
+                            };
+                        }
+                        if (payload.kind === 'vc-close') {
+                            const signature = await (0, omnia_factory_1.signVirtualChannelClose)(factory, payload.plan, localBundle);
+                            await localBundle.leaseProvider.commitKeyUse(signature.reservationId, `factory-vc-close-${payload.factoryId}`);
+                            return {
+                                type: 'VC_ACCEPT',
+                                channelId: payload.vcId,
+                                nonce: msg.nonce,
+                                payload: { kind: 'vc-close', signature },
+                            };
+                        }
+                        return null;
+                    }
+                    catch (e) {
+                        return {
+                            type: 'ERROR',
+                            channelId: msg.channelId,
+                            nonce: msg.nonce,
+                            payload: { error: String(e) },
+                        };
+                    }
+                });
+                if (reply)
+                    await peer.sendMessage(reply);
+            };
             unsubscribe = (0, omnia_1.createOmniaIntegration)(swarm, channelStore, {
                 signer: dependencies.signer,
                 leaseProvider: dependencies.leaseProvider,
                 chainProvider: dependencies.chainProvider ?? chainAdapter,
+                onFactoryMessage,
+                onVcMessage,
+                onSpliceMessage,
+                onPeerMessage,
+                onChannelAccepted,
+                onStateUpdated,
+                onSettlementProposed,
             });
+            const preparedPay = new Map();
+            const preparedSettle = new Map();
+            const preparedOpen = new Map();
+            const preparedSplice = new Map();
+            const preparedFactory = new Map();
+            const vtxoPools = new Map();
+            const vtxos = new Map();
+            const vtxoReceipts = new Map();
+            const preparedVtxoReceipts = new Map();
+            const pools = new Map();
+            const poolPositions = new Map();
             if (!controlServer) {
                 const readOnly = !dependencies.signer || !dependencies.leaseProvider;
                 if (readOnly) {
@@ -93,20 +467,53 @@ function createOmniaHost(config, dependencies = {}) {
                     isReady: () => started,
                     allowedOrigins: config.allowedOrigins,
                     authToken: config.controlToken,
+                    observe: observationStore ? {
+                        store: observationStore,
+                        bus: observationBus,
+                        snapshot: async () => (0, snapshot_js_1.createObservationSnapshot)({
+                            networkId: config.networkId ?? dependencies.networkId ?? 'omnia',
+                            sourceNodeId: config.sourceNodeId ?? dependencies.sourceNodeId ?? config.localPartyId ?? 'omnia-host',
+                            streamId: `${config.sourceNodeId ?? dependencies.sourceNodeId ?? config.localPartyId ?? 'omnia-host'}:${config.networkId ?? dependencies.networkId ?? 'omnia'}`,
+                            cursor: await observationStore.head(),
+                            channels: channelStore?.values(),
+                            factories: factories?.values(),
+                            vtxoPools: vtxoPools.values(),
+                            vtxos: vtxos.values(),
+                            pools: pools.values(),
+                            operations: (dependencies.operationStoreForApi ?? operationStore),
+                        }),
+                    } : undefined,
                     methods: dependencies.methods ?? (0, methods_js_1.createHostMethods)({
                         channels: channelStore,
                         routing: routingProvider,
                         operations: dependencies.operationStoreForApi ?? operationStore,
+                        observe: observation,
                         signer: dependencies.signer,
                         leaseProvider: dependencies.leaseProvider,
                         chainProvider: dependencies.chainProvider ?? chainAdapter,
                         swarm,
+                        channelPeers,
                         localParticipant,
-                        factories: dependencies.factories,
-                        factoryBundles: dependencies.factoryBundles,
-                        spliceProposals: dependencies.spliceProposals,
-                        spliceAcceptances: dependencies.spliceAcceptances,
-                        spliceLeaseProvider: dependencies.spliceLeaseProvider,
+                        transportPubkey: dependencies.transportPubkey,
+                        factories,
+                        factoryBundles,
+                        spliceProposals,
+                        spliceAcceptances,
+                        spliceLeaseProvider,
+                        custodyMode: config.custodyMode ?? 'self',
+                        signerPort: dependencies.signerPort,
+                        preparedPay,
+                        preparedSettle,
+                        preparedOpen,
+                        preparedSplice,
+                        preparedFactory,
+                        vtxoPools,
+                        vtxos,
+                        vtxoReceipts,
+                        preparedVtxoReceipts,
+                        pools,
+                        poolPositions,
+                        coordinator: !dependencies.signer && !config.readOnly,
                         fundingSigner: config.fundingPubkey
                             ? async (digest) => {
                                 const sig = await chainAdapter.signData(config.fundingPubkey, '0x' + Buffer.from(digest).toString('hex'));
@@ -116,6 +523,7 @@ function createOmniaHost(config, dependencies = {}) {
                         readOnly,
                         identity: dependencies.identity,
                         manifest: dependencies.manifest,
+                        p2pHubUrl,
                         refreshRouting: () => routingProvider.rebuild((0, routing_provider_js_1.channelGraphEdges)(channelStore.values())),
                     }),
                 });
@@ -127,6 +535,9 @@ function createOmniaHost(config, dependencies = {}) {
             catch (error) {
                 unsubscribe?.();
                 unsubscribe = undefined;
+                await p2pHubServer?.close();
+                p2pHubServer = undefined;
+                p2pHubUrl = undefined;
                 chainAdapter?.close();
                 await swarm?.close();
                 if (ownedOperationStore)
@@ -142,6 +553,9 @@ function createOmniaHost(config, dependencies = {}) {
                 return;
             unsubscribe?.();
             unsubscribe = undefined;
+            await p2pHubServer?.close();
+            p2pHubServer = undefined;
+            p2pHubUrl = undefined;
             await controlServer?.close();
             chainAdapter?.close();
             await swarm?.close();
@@ -150,6 +564,9 @@ function createOmniaHost(config, dependencies = {}) {
             else if (injectedOperationStore)
                 await injectedOperationStore.close();
             ownedOperationStore = undefined;
+            if (ownedObservationStore)
+                await ownedObservationStore.close();
+            ownedObservationStore = undefined;
             ownedStore?.close();
             ownedStore = undefined;
             started = false;

package/dist/observe/bus.d.ts

@@ -0,0 +1,13 @@
+import type { OmniaObservation } from "./types.js";
+export type ObservationListener = (observation: OmniaObservation) => void;
+/**
+ * In-process live fan-out for SSE consumers. The durable journal remains the
+ * source of truth: a subscriber that misses a live event still replays it from
+ * `ObservationStore.readSince(cursor)`.
+ */
+export declare class ObservationBus {
+    private readonly listeners;
+    subscribe(listener: ObservationListener): () => void;
+    publish(observation: OmniaObservation): void;
+    get size(): number;
+}

package/dist/observe/bus.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservationBus = void 0;
+/**
+ * In-process live fan-out for SSE consumers. The durable journal remains the
+ * source of truth: a subscriber that misses a live event still replays it from
+ * `ObservationStore.readSince(cursor)`.
+ */
+class ObservationBus {
+    listeners = new Set();
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    publish(observation) {
+        for (const listener of this.listeners) {
+            try {
+                listener(observation);
+            }
+            catch {
+                // A broken consumer must never break the mutation path.
+            }
+        }
+    }
+    get size() {
+        return this.listeners.size;
+    }
+}
+exports.ObservationBus = ObservationBus;

package/dist/observe/emitter.d.ts

@@ -0,0 +1,61 @@
+import type { OmniaChannel } from "@totemsdk/omnia";
+import type { ObservationBus } from "./bus.js";
+import type { ObservationDomain, ObservationEntity, ObservationPhase, ObservationRecord, ObservationStore, OmniaObservation } from "./types.js";
+export interface ObservationEmitterConfig {
+    store: ObservationStore;
+    bus: ObservationBus;
+    networkId: string;
+    sourceNodeId: string;
+    streamId?: string;
+    /** Mark events from fixture/simulated hosts. */
+    simulated?: boolean;
+    /** Called on emission failures (defaults to console.error). */
+    onError?: (error: unknown) => void;
+}
+export interface EmitObservationInput {
+    domain: ObservationDomain;
+    kind: string;
+    phase: ObservationPhase;
+    entity: ObservationEntity;
+    occurredAt?: number;
+    operationId?: string;
+    causationId?: string;
+    transitionHash?: string;
+    parties?: {
+        local?: string;
+        remote?: string;
+    };
+    token?: {
+        tokenId: string;
+        scale: number;
+    };
+    before?: Record<string, unknown>;
+    after?: Record<string, unknown>;
+    amounts?: ObservationRecord["amounts"];
+    chain?: ObservationRecord["chain"];
+    evidence?: ObservationRecord["evidence"];
+    simulated?: boolean;
+    data?: Record<string, unknown>;
+}
+/** Stable hash for transition identity (never includes secrets). */
+export declare function hashTransition(parts: Array<string | number | undefined | null>): string;
+/** Hash a channel's signed commitment for cross-node correlation. */
+export declare function channelTransitionHash(channel: OmniaChannel): string;
+export declare function hashString(value: string): string;
+/**
+ * Builds, redacts and persists observation events, then fans them out live.
+ *
+ * `emit()` never throws into a mutation: persistence/export failures are
+ * reported out-of-band so a payment can never be blocked by the observer.
+ */
+export declare class ObservationEmitter {
+    private readonly store;
+    private readonly bus;
+    private readonly networkId;
+    private readonly sourceNodeId;
+    private readonly streamId;
+    private readonly simulated;
+    private readonly onError;
+    constructor(config: ObservationEmitterConfig);
+    emit(input: EmitObservationInput): Promise<OmniaObservation | undefined>;
+}