@spider-mesh/core 2.0.40 → 2.0.42

package/README.md

@@ -1,47 +1,17 @@
 # Spider Mesh Core
 
-`@spider-mesh/core` is a lightweight TypeScript microservice core for service-to-service RPC, pubsub events, and node discovery with pluggable transporters.
+`@spider-mesh/core` is the runtime-agnostic Spider Mesh package.
 
 It provides:
 
-- Decorator-based local service registration
-- Typed remote service linking through a Proxy
-- Stream-first RPC over transporter-managed byte delivery
-- Discovery and pubsub integration through simple transporter contracts
-- Transporter contracts that can be implemented directly or consumed through companion transport packages such as `@spider-mesh/tcp` and `@spider-mesh/ws`
-- NestJS adapters for exposing and consuming services
+- local microservice registration with decorators
+- typed remote service linking through proxies
+- RPC, discovery, and pubsub transporter contracts
+- a `Registry` for remote peer state and RPC routing
+- a `SpiderMesh` runtime for local services, transporters, and node metadata
+- NestJS helper adapters
 
-## Package Boundary
-
-Spider Mesh is now split into two main package layers:
-
-- `@spider-mesh/core`: runtime-agnostic service runtime, decorators, linking, and shared contracts
-- companion transport packages: concrete transport implementations such as `@spider-mesh/tcp` and `@spider-mesh/ws`
-
-Keep companion packages on the same published version as `@spider-mesh/core` to avoid contract drift between the runtime and concrete transports.
-
-## Metadata Contract
-
-`SpiderMeshNode` is intentionally minimal.
-
-- Node metadata includes `host`, `namespace`, `node_id`, `version`, `services`, `nodes`, and `transporters`.
-- Node metadata no longer includes `ips`.
-- Node metadata no longer includes `online`.
-
-Discovery transporters should treat discovery as a node announcement stream, not as an interface-IP inventory.
-
-The discovery transporter contract is:
-
-```ts
-broadcast(data: MdnsMessage<NodeMetadata>): Promise<void>
-```
-
-`@spider-mesh/core` no longer passes a separate IP list into discovery transporters.
-
-If you are reading this package first, the practical rule is simple:
-
-- stay in `@spider-mesh/core` for service code and runtime code
-- add a companion transport package only when you explicitly need a concrete transport implementation
+Concrete transport implementations live in companion packages such as `@spider-mesh/tcp` and `@spider-mesh/ws`, or in your own custom transporters.
 
 ## Install
 
@@ -49,124 +19,38 @@ If you are reading this package first, the practical rule is simple:
 bun add @spider-mesh/core rxjs reflect-metadata
 ```
 
-If you also install a companion transport package, keep it on the same release version as `@spider-mesh/core`.
-
-This package is ESM-only.
-
-Practical implications:
-
-- published output is loaded as ESM through the root export map
-- repository TypeScript uses `module: NodeNext` and `moduleResolution: NodeNext`
-- internal relative imports use emitted `.js` specifiers, for example `./SpiderMesh.js`
-- avoid CommonJS patterns such as `require()` when adding new runtime code
-
-## AI Usage Guide
-
-Use this section as the canonical decision guide when generating code with AI tools.
-
-### Environment support matrix
+For TypeScript projects using decorators, enable decorator metadata in your compiler settings.
 
-| Runtime | `@spider-mesh/core` | `@spider-mesh/tcp` | `@spider-mesh/ws` |
-| --- | --- | --- | --- |
-| Node.js | Supported | Supported | Supported |
-| Bun | Supported | Supported | Supported |
-| Browser | Partially supported, depends on your custom transporter | Not recommended | Not recommended |
-| React Native | Supported for the core entry only | Not recommended | Not recommended |
+## Runtime Setup
 
-### Recommended imports
+Create a registry when you need remote peer discovery and RPC routing.
 
-Use these imports exactly.
-
-- Core runtime, decorators, RPC linking, NestJS helpers: `import { ... } from '@spider-mesh/core'`
-- Shared transporter contracts and runtime APIs: `import { ... } from '@spider-mesh/core'`
-- Companion TCP transport implementation when needed: `import { Http2Rpc, Http2Pubsub, UdpDiscovery } from '@spider-mesh/tcp'`
-- Companion WebSocket transport implementation when needed: `import { WebsocketTransporter } from '@spider-mesh/ws'`
-
-### When to use what
-
-- Use `SpiderMesh` when you need a local runtime that can expose services, discover nodes, publish events, or call remote services.
-- Use `@Microservice()` on local classes that should be callable remotely.
-- Use `RemoteServiceLinker.link()` when you need a typed remote proxy for another service.
-- Use transporter contracts from `@spider-mesh/core` when you are implementing or typing your own transport.
-- Use `@spider-mesh/tcp` or `@spider-mesh/ws` when you want a companion transport package.
-- Use a custom transporter when the runtime is not Node.js or Bun, or when you need a different protocol.
-
-### Do and don't
-
-Do:
-
-- Import runtime-agnostic APIs from `@spider-mesh/core`.
-- Import transporter contracts from `@spider-mesh/core` when you need transport typing.
-- Use a companion transport package such as `@spider-mesh/tcp` or `@spider-mesh/ws` when you need a ready-made transport implementation.
-- Wait for remote service availability with `wait()` before making calls in startup flows.
-- Treat companion package examples and e2e tests as canonical usage references for concrete transport behavior.
-
-Don't:
-
-- Do not assume `@spider-mesh/core` exports every concrete transporter.
-- Do not assume `@spider-mesh/tcp` is React Native-ready.
-- Do not assume `@spider-mesh/ws` is React Native-ready.
-- Do not couple service code to a single transport package unless that is intentional.
-- Do not call remote services before the target service has been discovered unless you intentionally rely on retry behavior.
-
-### Canonical recipes
-
-Provider recipe:
-
-1. Import `Microservice` and `SpiderMesh` from `@spider-mesh/core`.
-2. Choose a concrete transporter implementation, for example from `@spider-mesh/tcp` or `@spider-mesh/ws`.
-3. Define a class and decorate it with `@Microservice()`.
-4. Instantiate the service class.
-5. Create `new SpiderMesh({ transporters: [transporter] })`.
-
-Client recipe:
-
-1. Import `SpiderMesh` and `RemoteServiceLinker` from `@spider-mesh/core`.
-2. Choose a concrete transporter implementation, for example from `@spider-mesh/tcp` or `@spider-mesh/ws`.
-3. Create `new SpiderMesh({ transporters: [transporter] })`.
-4. Create a typed remote proxy with `RemoteServiceLinker.link()`.
-5. Call `await proxy.wait()` before the first RPC call.
-
-Companion transport package recipes:
-
-TCP:
-
-1. Import `UdpDiscovery`, `Http2Rpc`, and `Http2Pubsub` from `@spider-mesh/tcp`.
-2. Add those transporters to `new SpiderMesh({ transporters: [...] })`.
-3. Let the TCP package handle discovery, RPC, and pubsub transport.
-
-WebSocket:
-
-1. Import `WebsocketTransporter` from `@spider-mesh/ws`.
-2. Add that transporter to `new SpiderMesh({ transporters: [...] })`.
-3. Run `WebsocketRelayServer` from `@spider-mesh/ws/relay-server` when using the WebSocket companion package.
-
-### AI-safe assumptions
+```ts
+import { Registry, SpiderMesh } from '@spider-mesh/core'
 
-An AI agent should assume the following unless the codebase says otherwise:
+const registry = new Registry()
+const mesh = new SpiderMesh(registry)
+```
 
-- The root package entry is the safe default for shared runtime APIs.
-- Concrete transports are opt-in through companion packages or custom implementations.
-- Transporter contracts come from the core package.
-- The companion TCP and WebSocket packages are sibling transport options for Node.js and Bun runtimes.
-- If the target runtime is React Native, prefer the core APIs and a runtime-appropriate custom transporter.
+Register transporter instances on the runtime:
 
-## Core Model
+```ts
+import { Http2Pubsub, Http2Rpc, UdpDiscovery } from '@spider-mesh/tcp'
 
-`SpiderMesh` is the runtime coordinator.
+mesh.registerTransporter(new UdpDiscovery())
+mesh.registerTransporter(new Http2Rpc())
+mesh.registerTransporter(new Http2Pubsub())
+```
 
-It keeps track of:
+Transporter capability is inferred by instance shape:
 
-- The current node metadata
-- Local service instances registered in the process
-- Remote nodes discovered from discovery transporters
-- RPC-capable nodes for each service
-- RPC pending and running stream state
-- Pubsub, RPC, and discovery transporters
+- `send()` => RPC transporter
+- `publish()` => pubsub transporter
+- `broadcast()` => discovery transporter
 
-## Quick Start
+## Local Services
 
-### 1. Define a local microservice
+Use `@Microservice()` on local service classes and instantiate them normally.
 
 ```ts
 import { BeforeMicroserviceOnline, Microservice } from '@spider-mesh/core'
@@ -185,203 +69,222 @@ export class UserService {
     return { id, name: 'Ada' }
   }
 }
+
+new UserService()
 ```
 
-`@Microservice()` registers the instance into Spider Mesh when the class is constructed.
+`@Microservice()` emits the constructed instance into the shared `LOCAL_SERVICES$` stream. `SpiderMesh` subscribes to that stream and adds the service to local node metadata.
 
-`@BeforeMicroserviceOnline()` marks async setup methods that must complete before the service is exposed in local metadata.
+## Remote Services
 
-### 2. Create the runtime
+Create a typed remote client with `RemoteServiceLinker.link()`.
 
 ```ts
-import { SpiderMesh } from '@spider-mesh/core'
-import { AppDiscoveryTransporter } from './AppDiscoveryTransporter.js'
-import { AppRpcTransporter } from './AppRpcTransporter.js'
-import { AppPubsubTransporter } from './AppPubsubTransporter.js'
-
-const mesh = new SpiderMesh({
-  transporters: [
-    AppDiscoveryTransporter,
-    AppRpcTransporter,
-    AppPubsubTransporter,
-  ],
-})
-```
-
-These transporter class names are application-local examples, not exports from `@spider-mesh/core`.
-
-Transporter capability is inferred by method shape:
-
-- `send()` means RPC transporter
-- `publish()` means pubsub transporter
-- `broadcast()` means discovery transporter
+import { RemoteServiceLinker } from '@spider-mesh/core'
 
-You can pass either transporter classes or already-created transporter instances into `transporters`.
+type UserServiceContract = {
+  getUser(id: string): Promise<{ id: string; name: string }>
+}
 
-### 2a. Use companion transport packages
+const users = RemoteServiceLinker.link<UserServiceContract>(mesh, {
+  service: 'UserService',
+})
 
-Spider Mesh can work with companion transport packages such as `@spider-mesh/tcp` and `@spider-mesh/ws`.
+await users.wait()
 
-The root package entry exports the runtime-agnostic APIs and shared transporter contracts. Concrete transport implementations can be imported from companion packages when needed.
+const user = await users.getUser('42')
+```
 
-Create a runtime using the TCP package:
+Remote methods return RxJS observables and can also be awaited.
 
 ```ts
-import { SpiderMesh } from '@spider-mesh/core'
-import { Http2Pubsub, Http2Rpc, UdpDiscovery } from '@spider-mesh/tcp'
+const user = await users.getUser('42')
 
-const mesh = new SpiderMesh({
-  transporters: [
-    new UdpDiscovery(),
-    new Http2Rpc(),
-    new Http2Pubsub(),
-  ],
+users.getUser('42').subscribe(value => {
+  console.log(value)
 })
 ```
 
-Or use the WebSocket package:
+### Waiting and watching
 
 ```ts
-import { SpiderMesh } from '@spider-mesh/core'
-import { WebsocketTransporter } from '@spider-mesh/ws'
+await users.wait(nodes => nodes.length > 0)
 
-const transporter = new WebsocketTransporter({
-  heartbeatIntervalMs: 5000,
-  reconnectIntervalMs: 1000,
+users.watch().subscribe(nodes => {
+  console.log(nodes.map(node => node.node_id))
 })
 
-transporter.connect('ws://127.0.0.1:8787')
+console.log(users.nodes)
+```
+
+### Fan-out calls
 
-const mesh = new SpiderMesh({
-  transporters: [transporter],
+```ts
+users.__batch__getUser('42').subscribe(result => {
+  console.log(result)
 })
 ```
 
-Both patterns keep service/runtime code in `@spider-mesh/core` while delegating concrete transport behavior to a companion package.
-
-### 2b. Minimal working startup order
+Each emission is either `{ node, data }` or `{ node, error }`.
 
-When using a discovery-based transport package, the canonical startup order is:
+## RPC Options
 
-1. Start one or more provider processes that register local `@Microservice()` classes.
-2. Start client processes.
-3. Wait for discovery to converge.
-4. In clients, call `await remote.wait()` before the first remote method call.
+The current `RpcOptions` shape is:
 
-If an AI agent needs one default operational pattern, use this startup order.
+```ts
+type RpcOptions<T = any> = {
+  service: string
+  method: string
+  args: any[]
+  fallback?: T
+  timeout?: number
+  retry?: number
+  node_id?: string
+  transporter?: string | { name?: string }
+}
+```
 
-### 3. Call a remote service
+Examples:
 
 ```ts
-import { RemoteServiceLinker } from '@spider-mesh/core'
-
-type UserServiceContract = {
-  getUser(id: string): Promise<{ id: string; name: string }>
-}
+await users.set({ timeout: 3000, retry: 2 }).getUser('42')
 
-const users = RemoteServiceLinker.link<UserServiceContract>(mesh, {
+await mesh.callRemoteService({
   service: 'UserService',
+  method: 'getUser',
+  args: ['42'],
+  transporter: 'Http2Rpc',
 })
-
-await users.wait()
-
-const user = await users.getUser('42')
-console.log(user.name)
 ```
 
-Remote methods are exposed through a typed Proxy.
+`transporter` may be:
 
-## RPC Behavior
+- a registered transporter name string
+- a class or object with a `name`
 
-### Awaitable observable calls
+## Events
 
-Remote method calls return an RxJS observable that is also awaitable.
+Use `SpiderMesh.linkEvent()` to bind a topic by event class name.
 
 ```ts
-const user = await users.getUser('42')
-```
+class UserCreatedEvent {
+  constructor(
+    public readonly id: string,
+    public readonly email: string,
+  ) {}
+}
 
-```ts
-users.getUser('42').subscribe(user => {
-  console.log(user)
+const userCreated = mesh.linkEvent(UserCreatedEvent)
+
+await userCreated.publish(new UserCreatedEvent('42', 'ada@example.com'))
+
+const sub = userCreated.listen().subscribe(event => {
+  console.log(event.id)
 })
+
+sub.unsubscribe()
 ```
 
-### Stream-first RPC
+Current event behavior:
 
-Spider Mesh treats every RPC response as a stream.
+- `publish()` fans out through all registered pubsub transporters
+- `listen()` merges all transporter listeners into one shared stream
+- first subscribe adds the topic to local node metadata
+- last unsubscribe removes the topic from local node metadata
+- discovery transporters rebroadcast node metadata after topic changes
 
-- If a local method returns an `Observable`, each emission is forwarded to the caller.
-- If a local method returns a `Promise` or plain value, it is sent as one `data` event with `completed: true`.
-- If the caller unsubscribes early, Spider Mesh sends a `cancel` packet so the remote node can stop the running stream.
+## Registry
 
-### Per-link defaults
+`Registry` stores remote peer and RPC routing state.
 
-```ts
-const resilientUsers = users.set({
-  timeout: 3000,
-  retry: 2,
-  fallback: { id: 'fallback', name: 'Unknown' },
-})
+Current public methods:
 
-const user = await resilientUsers.getUser('42')
-```
+- `getPeer(nodeId)`
+- `upsertPeer(node)`
+- `removePeer(nodeId)`
+- `listPeers({ service? })`
+- `watch(service?)`
+- `pickRpcNode(service, { node_id? })`
+- `getRpcTransporterName(service, { node_id? })`
+- `listTopicNodes(topic)`
 
-Supported RPC options:
+## Transporter Contracts
 
-- `service`: remote service name
-- `method`: remote method name
-- `args`: positional arguments
-- `timeout`: timeout per inactivity window in milliseconds
-- `retry`: retry count for offline errors
-- `fallback`: fallback value when the call fails
-- `node_id`: force routing to a specific node
-- `ip`: force routing to a specific node IP
+The contract source of truth is `src/types.ts`.
 
-### Waiting and watching
+### RPC transporter
 
 ```ts
-await users.wait(nodes => nodes.length >= 2)
+type RpcTransporter = Observable<RpcEvent> & {
+  linkRegistry?(registry: Registry): void
+  send(data: RpcPacket, node_id?: string): Promise<void>
+}
+```
 
-users.watch().subscribe(nodes => {
-  console.log(nodes.map(node => node.node_id))
-})
+### Pubsub transporter
 
-console.log(users.nodes)
+```ts
+type PubsubTransporter = {
+  publish<T>(topic: string, data: T): Promise<void>
+  listen<T>(topic: string): Observable<T>
+  linkRegistry?(registry: Registry): void
+}
 ```
 
-`wait()` resolves when a service availability condition is met.
+### Discovery transporter
 
-`watch()` streams matching nodes whenever topology changes.
+```ts
+type DiscoveryTransporter = Observable<DiscoveryEvent> & {
+  linkRegistry?(registry: Registry): void
+  broadcast(data: MdnsMessage<NodeMetadata>): Promise<void>
+}
+```
 
-`nodes` returns the current RPC-capable node list for that service.
+## NestJS Helpers
 
-### Fan-out calls across all nodes
+The package exports:
 
-```ts
-users.__batch__getUser('42').subscribe(result => {
-  console.log(result)
-})
-```
+- `NestJSExposeMicroservice(factory, metadata?)`
+- `NestJSLinkMicroservice(factory, transporter)`
+- `NestJSLinkEvent(factory)`
 
-Each emission is either:
+`NestJSLinkMicroservice(factory, transporter)` forwards the transporter selector into `RemoteServiceLinker.link()`.
 
-- `{ node, data }`
-- `{ node, error }`
+## Companion Packages
 
-## Events
+Use companion packages when you need concrete transport implementations.
 
-`SpiderMesh.linkEvent()` binds a topic using the event class name.
+- `@spider-mesh/tcp`
+- `@spider-mesh/ws`
 
-```ts
-class UserCreatedEvent {
-  constructor(
-    public readonly id: string,
-    public readonly email: string,
-  ) {}
-}
+Keep runtime logic in `@spider-mesh/core` and import concrete transporters explicitly from the companion package.
 
-const userCreated = mesh.linkEvent(UserCreatedEvent)
+## Tests And Validation
+
+The repository includes mock e2e coverage for:
+
+- RPC routing by transporter selector
+- async `RemoteServiceLinker.wait()` behavior
+- topic metadata lifecycle for `linkEvent()`
+- RPC routing across isolated child processes
+
+Run tests with:
+
+```bash
+bun run test:e2e
+```
+
+Build with:
+
+```bash
+bun run build
+```
+
+## Notes
+
+- This package is ESM-only.
+- Repository source uses emitted `.js` relative specifiers.
+- `LOCAL_SERVICES$` is process-global inside one process.
 
 await userCreated.publish(new UserCreatedEvent('42', 'ada@example.com'))
 

package/build/src/Registry.d.ts

@@ -0,0 +1,19 @@
+import { BehaviorSubject } from 'rxjs';
+import type { SpiderMeshNode } from './types.js';
+export type RegistryPickRpcTargetOptions = {
+    node_id?: string;
+};
+export declare class Registry {
+    #private;
+    readonly nodes$: BehaviorSubject<Map<string, SpiderMeshNode>>;
+    getPeer(nodeId: string): SpiderMeshNode | undefined;
+    upsertPeer(node: SpiderMeshNode): SpiderMeshNode;
+    removePeer(nodeId: string): boolean;
+    listPeers(options?: {
+        service?: string;
+    }): SpiderMeshNode[];
+    watch(service?: string): import("rxjs").Observable<SpiderMeshNode[]>;
+    pickRpcNode(service: string, options?: RegistryPickRpcTargetOptions): string | null;
+    getRpcTransporterName(service: string, options?: RegistryPickRpcTargetOptions): string | null;
+    listTopicNodes(topic: string): SpiderMeshNode[];
+}

package/build/src/Registry.js

@@ -0,0 +1,77 @@
+import { BehaviorSubject, map } from 'rxjs';
+export class Registry {
+    nodes$ = new BehaviorSubject(new Map());
+    #rrIndexes = new Map();
+    getPeer(nodeId) {
+        return this.nodes$.value.get(nodeId);
+    }
+    upsertPeer(node) {
+        const nodes = new Map(this.nodes$.value);
+        const current = nodes.get(node.node_id);
+        nodes.set(node.node_id, {
+            ...current,
+            ...node,
+            topics: node.topics || current?.topics || [],
+            services: {
+                ...(current?.services || {}),
+                ...(node.services || {})
+            },
+            nodes: {
+                ...(current?.nodes || {}),
+                ...(node.nodes || {})
+            },
+            transporters: {
+                ...(current?.transporters || {}),
+                ...(node.transporters || {})
+            }
+        });
+        this.nodes$.next(nodes);
+        return nodes.get(node.node_id);
+    }
+    removePeer(nodeId) {
+        const nodes = new Map(this.nodes$.value);
+        const deleted = nodes.delete(nodeId);
+        if (deleted) {
+            this.nodes$.next(nodes);
+        }
+        return deleted;
+    }
+    listPeers(options = {}) {
+        return [...this.nodes$.value.values()].filter(node => {
+            if (options.service && node.services[options.service] == undefined)
+                return false;
+            return true;
+        });
+    }
+    watch(service) {
+        return this.nodes$.pipe(map(() => this.listPeers({ service })));
+    }
+    pickRpcNode(service, options = {}) {
+        if (options.node_id) {
+            const node = this.getPeer(options.node_id);
+            if (!node)
+                return null;
+            if (node.services[service] == undefined)
+                return null;
+            return node.node_id;
+        }
+        const targets = this.listPeers({ service });
+        if (targets.length === 0)
+            return null;
+        const index = this.#rrIndexes.get(service) || 0;
+        this.#rrIndexes.set(service, (index + 1) % targets.length);
+        return targets[index % targets.length]?.node_id || null;
+    }
+    getRpcTransporterName(service, options = {}) {
+        const nodeId = options.node_id || this.pickRpcNode(service, options);
+        if (!nodeId)
+            return null;
+        const node = this.getPeer(nodeId);
+        const transporter = node?.transporters?.rpc;
+        return typeof transporter === 'string' ? transporter : null;
+    }
+    listTopicNodes(topic) {
+        return [...this.nodes$.value.values()].filter(node => node.topics.includes(topic));
+    }
+}
+//# sourceMappingURL=Registry.js.map

package/build/src/Registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Registry.js","sourceRoot":"","sources":["../../src/Registry.ts"],"names":[],"mappings":"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"}