@serfab/cadre-core 0.0.2

package/README.md

@@ -0,0 +1,252 @@
+# @serfab/cadre-core
+
+Core library for Sereus cadre nodes—the infrastructure that enables parties to manage their personal cluster of nodes participating in distributed strand networks.
+
+## Why Sereus Cadre Core?
+
+In traditional distributed systems, users depend on centralized services to manage their data and identities. **Sereus** inverts this model: each user (or "party") controls their own **cadre**—a personal cluster of nodes ranging from always-on cloud servers to intermittently-connected mobile devices.
+
+The cadre architecture provides:
+
+- **Sovereignty**: Your data lives on your nodes, under your control
+- **Resilience**: Multiple nodes means no single point of failure
+- **Flexibility**: Mix cloud servers, home NAS, laptops, and phones
+- **Privacy**: Cryptographic authorization without central servers
+
+A cadre doesn't exist in isolation. Cadres participate in **strands**—shared data spaces where multiple parties collaborate. When you join a messaging app, your cadre joins that strand. When you share a document, you're creating a strand between your cadre and theirs.
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                              Your Cadre                                  │
+│                                                                          │
+│  ┌────────────────────────────────────────────────────────────────────┐ │
+│  │                        Control Network                              │ │
+│  │            (Private Optimystic DB for cadre management)             │ │
+│  │                                                                     │ │
+│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐           │ │
+│  │  │ Phone    │──│ Laptop   │──│ Cloud    │──│ NAS      │           │ │
+│  │  │ (edge)   │  │ (edge)   │  │ (core)   │  │ (core)   │           │ │
+│  │  └──────────┘  └──────────┘  └──────────┘  └──────────┘           │ │
+│  └────────────────────────────────────────────────────────────────────┘ │
+│                                    │                                     │
+│              ┌─────────────────────┼─────────────────────┐              │
+│              ▼                     ▼                     ▼              │
+│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐      │
+│  │ Strand A         │  │ Strand B         │  │ Strand C         │      │
+│  │ (Chat App)       │  │ (Shared Docs)    │  │ (Photo Backup)   │      │
+│  └──────────────────┘  └──────────────────┘  └──────────────────┘      │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+Each `CadreNode` instance:
+1. **Connects to the control network** - A private Optimystic database shared only by your nodes
+2. **Watches for strand changes** - Automatically detects when you join or leave strands
+3. **Manages strand instances** - Spins up isolated libp2p networks for each strand
+4. **Handles peer enrollment** - Cryptographically authorizes new devices to join your cadre
+
+## Installation
+
+```bash
+npm install @serfab/cadre-core
+```
+
+## Quick Start
+
+```typescript
+import { CadreNode } from '@serfab/cadre-core';
+import { FileRawStorage } from '@optimystic/db-p2p-storage-fs';
+
+const node = new CadreNode({
+  controlNetwork: {
+    partyId: 'your-unique-party-id',
+    bootstrapNodes: ['/ip4/192.168.1.100/tcp/4001/p2p/12D3KooW...']
+  },
+  profile: 'storage',  // 'storage' for servers, 'transaction' for mobile
+  storage: {
+    // Storage provider factory - called with strandId for strand-isolated storage
+    provider: (strandId) => new FileRawStorage(`/data/sereus/${strandId}`),
+    quotaBytes: 10 * 1024 * 1024 * 1024  // 10 GB
+  }
+});
+
+// Start the node
+await node.start();
+console.log('Node started with Peer ID:', node.peerId?.toString());
+
+// Listen for strand events
+node.on('strand:started', ({ strandId }) => {
+  console.log('Joined strand:', strandId);
+});
+
+// Check active strands
+for (const [id, strand] of node.getStrands()) {
+  console.log(`Strand ${id}: ${strand.status}, ${strand.connectedPeers} peers`);
+}
+
+// Graceful shutdown
+await node.stop();
+```
+
+## Node Profiles
+
+| Profile | Storage Role | Use Case | Ring Participation |
+|---------|--------------|----------|-------------------|
+| **transaction** | Ring Zulu only | Mobile devices, intermittent connectivity | Transaction verification, caching |
+| **storage** | Ring Zulu + Storage Rings | Servers, NAS, always-on nodes | Full archival storage |
+
+Both profiles participate in transaction consensus. The distinction is long-term storage commitment.
+
+## Strand Filtering
+
+Mobile apps typically shouldn't participate in all strands. Use filters to control participation:
+
+```typescript
+// Only participate in strands for a specific app
+strandFilter: { mode: 'appId', appId: 'com.example.chat' }
+
+// Only participate in one specific strand
+strandFilter: { mode: 'strandId', strandId: 'strand-abc123' }
+
+// Control network only, no strand participation
+strandFilter: { mode: 'none' }
+
+// Participate in all strands (default for servers)
+strandFilter: { mode: 'all' }
+```
+
+## Enrolling New Devices
+
+Adding a new device to your cadre uses the Seed Bootstrap API:
+
+```typescript
+// On the new device: generate identity
+const enrollment = new EnrollmentService();
+const { peerId, privateKey } = await enrollment.createCadrePeer();
+// Store privateKey securely, send peerId + multiaddrs to authority
+
+// On authority device: authorize the new peer and create seed
+await node.authorizePeer(newDevicePeerId, newDeviceMultiaddrs);
+const seed = await node.createSeed();
+
+// Deliver seed to new device (via protocol, API, or out-of-band)
+await node.deliverSeed(newDeviceMultiaddr, seed);
+// Or encode for QR/link: const encoded = node.encodeSeed(seed);
+
+// On new device: apply seed to join cadre
+const result = await newNode.applySeed(seed);
+```
+
+For provider-hosted drones, use the helper:
+
+```typescript
+// Get drone info from provider API
+const droneInfo = await provider.createContainer(plan);
+
+// One call: authorize + create seed
+const { seed, encodedSeed } = await node.addDrone({
+  dronePeerId: droneInfo.peerId,
+  droneMultiaddrs: droneInfo.multiaddrs
+});
+
+// Send to provider for drone initialization
+await provider.applySeed(droneInfo.containerId, encodedSeed);
+```
+
+## API Reference
+
+### CadreNode
+
+The main entry point for cadre participation.
+
+| Method | Description |
+|--------|-------------|
+| `start()` | Connect to control network and begin strand participation |
+| `stop()` | Gracefully disconnect from all networks |
+| `getStrands()` | Get all active strand instances |
+| `getStrand(id)` | Get a specific strand instance |
+| `addStrand(row)` | Manually add a strand (testing/direct API) |
+| `removeStrand(id)` | Manually remove a strand |
+| `getEnrollmentService()` | Access peer enrollment API |
+
+### Events
+
+| Event | Payload | Description |
+|-------|---------|-------------|
+| `control:connected` | - | Connected to control network |
+| `control:disconnected` | - | Disconnected from control network |
+| `strand:started` | `{ strandId }` | Strand instance started |
+| `strand:stopped` | `{ strandId }` | Strand instance stopped |
+| `strand:error` | `{ strandId, error }` | Error in strand instance |
+
+## Related Documentation
+
+- **[Cadre Architecture](../../docs/cadre-architecture.md)** - Deep dive into the cadre system design
+- **[Strand Management](../../docs/strands.md)** - How strands connect multiple cadres
+- **[Schema Guide](../../docs/schema-guide.md)** - Optimystic schema definitions
+
+## React Native Support
+
+This package is compatible with React Native. For mobile apps, use the RN-specific storage provider:
+
+```typescript
+import { CadreNode } from '@serfab/cadre-core';
+import { RNRawStorage } from '@optimystic/db-p2p-storage-rn';
+import { webSockets } from '@libp2p/websockets';
+import { circuitRelayTransport } from '@libp2p/circuit-relay-v2';
+
+const node = new CadreNode({
+  controlNetwork: {
+    partyId: 'your-unique-party-id',
+    bootstrapNodes: ['/dns4/relay.example.com/tcp/443/wss/p2p/12D3KooW...']
+  },
+  profile: 'transaction',  // Mobile devices typically use transaction profile
+  strandFilter: { mode: 'sAppId', sAppId: 'com.example.myapp' },
+  storage: {
+    // RN storage provider creates strand-isolated AsyncStorage
+    provider: (strandId) => new RNRawStorage(strandId)
+  },
+  network: {
+    // TCP doesn't work in React Native — use WebSocket transport instead
+    transports: [webSockets(), circuitRelayTransport()],
+    listenAddrs: []  // RN nodes typically cannot listen
+  }
+});
+```
+
+### Storage Provider Pattern
+
+The `storage.provider` option accepts either:
+- **An `IRawStorage` instance** - Shared storage for all strands
+- **A factory function** `(strandId: string) => IRawStorage` - Creates isolated storage per strand (recommended)
+
+Available storage implementations:
+| Package | Environment | Description |
+|---------|-------------|-------------|
+| `@optimystic/db-p2p` | All | `MemoryRawStorage` - In-memory (testing only) |
+| `@optimystic/db-p2p-storage-fs` | Node.js | `FileRawStorage` - File system storage |
+| `@optimystic/db-p2p-storage-rn` | React Native | `RNRawStorage` - AsyncStorage-based |
+
+### React Native Considerations
+
+1. **Network Transport**: libp2p's TCP transport doesn't work in RN. Pass `transports: [webSockets(), circuitRelayTransport()]` in the `network` config (see example above).
+
+2. **Schema Loading**: The control schema is embedded in the package. Do not set `schemaPath` in React Native.
+
+3. **Profile**: Mobile devices should use `profile: 'transaction'` for battery/bandwidth efficiency.
+
+4. **Strand Filtering**: Always filter strands on mobile to avoid participating in unnecessary networks.
+
+## Related Packages
+
+- **[@serfab/strand-proto](../strand-proto/)** - Strand initialization protocol
+- **[@optimystic/db-core](https://github.com/gotchoices/optimystic)** - Distributed database core
+- **[@optimystic/db-p2p](https://github.com/gotchoices/optimystic)** - libp2p integration for Optimystic
+- **[@optimystic/db-p2p-storage-fs](https://github.com/gotchoices/optimystic)** - File system storage (Node.js)
+- **[@optimystic/db-p2p-storage-rn](https://github.com/gotchoices/optimystic)** - AsyncStorage (React Native)
+
+## License
+
+MIT
+

package/dist/arachnode-stub.d.ts

@@ -0,0 +1,60 @@
+import type { NodeProfile, ArachnodeConfig } from './types.js';
+/**
+ * Ring configuration for a storage node
+ */
+export interface RingConfig {
+    /** Ring number (0 = full keyspace, higher = more partitions) */
+    ring: number;
+    /** Partition within the ring (depends on ring level) */
+    partition: number;
+    /** Keyspace range this node is responsible for */
+    keyspaceStart: Uint8Array;
+    keyspaceEnd: Uint8Array;
+}
+/**
+ * Stub implementation of Arachnode ring participation.
+ *
+ * Arachnode uses a concentric ring system where:
+ * - Ring Zulu (transaction ring): All nodes participate for transaction verification
+ * - Storage rings (0, 1, 2, 3...): Nodes join based on their storage capacity
+ *   - Ring 0: Full keyspace (requires most storage)
+ *   - Ring 1: 2 partitions
+ *   - Ring 2: 4 partitions
+ *   - Ring 3: 8 partitions
+ *   - etc.
+ *
+ * This is a stub that will be replaced when arachnode is fully implemented.
+ */
+export declare class ArachnodeStub {
+    private readonly profile;
+    private readonly config;
+    private ringConfig?;
+    private running;
+    constructor(profile: NodeProfile, config: ArachnodeConfig);
+    /**
+     * Start participating in rings
+     */
+    start(): Promise<void>;
+    /**
+     * Stop participating in rings
+     */
+    stop(): Promise<void>;
+    /**
+     * Get current ring configuration
+     */
+    getRingConfig(): RingConfig | undefined;
+    /**
+     * Check if participating in Ring Zulu
+     */
+    isInRingZulu(): boolean;
+    /**
+     * Check if participating in a storage ring
+     */
+    isInStorageRing(): boolean;
+    private calculateKeyspaceStart;
+    private calculateKeyspaceEnd;
+}
+/**
+ * Create an arachnode instance for a strand
+ */
+export declare function createArachnodeStub(profile: NodeProfile, config?: Partial<ArachnodeConfig>): ArachnodeStub;

package/dist/arachnode-stub.js

@@ -0,0 +1,120 @@
+import debug from 'debug';
+const log = debug('sereus:cadre:arachnode');
+/**
+ * Stub implementation of Arachnode ring participation.
+ *
+ * Arachnode uses a concentric ring system where:
+ * - Ring Zulu (transaction ring): All nodes participate for transaction verification
+ * - Storage rings (0, 1, 2, 3...): Nodes join based on their storage capacity
+ *   - Ring 0: Full keyspace (requires most storage)
+ *   - Ring 1: 2 partitions
+ *   - Ring 2: 4 partitions
+ *   - Ring 3: 8 partitions
+ *   - etc.
+ *
+ * This is a stub that will be replaced when arachnode is fully implemented.
+ */
+export class ArachnodeStub {
+    constructor(profile, config) {
+        this.running = false;
+        this.profile = profile;
+        this.config = config;
+        log('ArachnodeStub created for profile=%s, config=%o', profile, config);
+    }
+    /**
+     * Start participating in rings
+     */
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        // All nodes participate in Ring Zulu
+        if (this.config.enableRingZulu) {
+            log('Joining Ring Zulu (transaction ring)');
+            // Stub: In real implementation, would register with transaction verification network
+        }
+        // Storage nodes join storage rings
+        if (this.profile === 'storage' && this.config.storageRing) {
+            const { ring, partition = 0 } = this.config.storageRing;
+            log('Joining storage ring %d, partition %d', ring, partition);
+            // Calculate keyspace range for this partition
+            // Stub: Using placeholder keyspace calculation
+            this.ringConfig = {
+                ring,
+                partition,
+                keyspaceStart: this.calculateKeyspaceStart(ring, partition),
+                keyspaceEnd: this.calculateKeyspaceEnd(ring, partition)
+            };
+            // Stub: In real implementation, would:
+            // 1. Register with the storage ring
+            // 2. Begin accepting block storage requests for our keyspace
+            // 3. Participate in replication with other ring members
+        }
+        log('ArachnodeStub started');
+    }
+    /**
+     * Stop participating in rings
+     */
+    async stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.ringConfig) {
+            log('Leaving storage ring %d, partition %d', this.ringConfig.ring, this.ringConfig.partition);
+            // Stub: In real implementation, would gracefully leave the ring
+            this.ringConfig = undefined;
+        }
+        if (this.config.enableRingZulu) {
+            log('Leaving Ring Zulu');
+            // Stub: In real implementation, would leave transaction ring
+        }
+        log('ArachnodeStub stopped');
+    }
+    /**
+     * Get current ring configuration
+     */
+    getRingConfig() {
+        return this.ringConfig;
+    }
+    /**
+     * Check if participating in Ring Zulu
+     */
+    isInRingZulu() {
+        return this.running && this.config.enableRingZulu;
+    }
+    /**
+     * Check if participating in a storage ring
+     */
+    isInStorageRing() {
+        return this.running && this.ringConfig !== undefined;
+    }
+    // Stub keyspace calculations
+    calculateKeyspaceStart(ring, partition) {
+        // Stub: Real implementation would calculate based on ring partition scheme
+        const numPartitions = Math.pow(2, ring);
+        const partitionSize = 256 / numPartitions;
+        const start = new Uint8Array(32);
+        start[0] = Math.floor(partition * partitionSize);
+        return start;
+    }
+    calculateKeyspaceEnd(ring, partition) {
+        // Stub: Real implementation would calculate based on ring partition scheme
+        const numPartitions = Math.pow(2, ring);
+        const partitionSize = 256 / numPartitions;
+        const end = new Uint8Array(32);
+        end[0] = Math.floor((partition + 1) * partitionSize) - 1;
+        end.fill(0xFF, 1); // Fill rest with max values
+        return end;
+    }
+}
+/**
+ * Create an arachnode instance for a strand
+ */
+export function createArachnodeStub(profile, config) {
+    const fullConfig = {
+        enableRingZulu: config?.enableRingZulu ?? true,
+        storageRing: profile === 'storage' ? (config?.storageRing ?? { ring: 0 }) : undefined
+    };
+    return new ArachnodeStub(profile, fullConfig);
+}
+//# sourceMappingURL=arachnode-stub.js.map

package/dist/arachnode-stub.js.map

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

package/dist/cadre-node.d.ts

@@ -0,0 +1,252 @@
+import type { Libp2p, PeerId } from '@libp2p/interface';
+import type { CadreNodeConfig, StrandInstance, StrandConfig, SAppConfig, CadreNodeEvents, ControlNetworkSeed, ApplySeedResult, AddDroneOptions, AddPhoneOptions, DroneInitResult, InviteResult, CadreInvite, OpenInvitation, FormStrandResult, StrandFormationDisclosure } from './types.js';
+import { type SAppIdLookup } from './strand-watcher.js';
+import { EnrollmentService } from './enrollment.js';
+import { ControlDatabase } from './control-database.js';
+import { SeedBootstrapService } from './seed-bootstrap.js';
+import { StrandSolicitationService, type StrandSolicitationServiceOptions } from './strand-solicitation.js';
+type EventHandler<T> = (data: T) => void;
+/**
+ * CadreNode is the main entry point for a cadre member.
+ * It manages:
+ * - Connection to the control network
+ * - Watching for strand changes
+ * - Starting/stopping strand instances
+ * - Strand hibernation lifecycle
+ * - Peer enrollment
+ */
+export declare class CadreNode implements SAppIdLookup {
+    private readonly config;
+    private controlNode;
+    private controlDatabase;
+    private strandWatcher;
+    private strandManager;
+    private hibernationManager;
+    private enrollmentService;
+    private seedBootstrapService;
+    private strandSolicitationService;
+    private running;
+    private eventHandlers;
+    /** Map of strandId -> sAppConfig for sAppId filtering and management */
+    private sAppConfigs;
+    constructor(config: CadreNodeConfig);
+    /**
+     * SAppIdLookup implementation - get sAppId for a strand
+     */
+    getSAppId(strandId: string): string | undefined;
+    /**
+     * Get the peer ID of this node (available after start)
+     */
+    get peerId(): PeerId | undefined;
+    /**
+     * Get the multiaddrs of this node (available after start)
+     */
+    getMultiaddrs(): string[];
+    /**
+     * Check if the node is running
+     */
+    get isRunning(): boolean;
+    /**
+     * Get all strand instances
+     */
+    getStrands(): Map<string, StrandInstance>;
+    /**
+     * Get a specific strand instance
+     */
+    getStrand(strandId: string): StrandInstance | undefined;
+    /**
+     * Get the enrollment service for adding new peers
+     */
+    getEnrollmentService(): EnrollmentService;
+    /**
+     * Start the cadre node
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the cadre node
+     */
+    stop(): Promise<void>;
+    /**
+     * Subscribe to events
+     */
+    on<K extends keyof CadreNodeEvents>(event: K, handler: EventHandler<CadreNodeEvents[K]>): void;
+    /**
+     * Unsubscribe from events
+     */
+    off<K extends keyof CadreNodeEvents>(event: K, handler: EventHandler<CadreNodeEvents[K]>): void;
+    private emit;
+    private createControlNode;
+    private createStrandQueryable;
+    /**
+     * Schedule self-registration in the CadrePeer table.
+     * This runs as a background task after the node is started.
+     */
+    private scheduleSelfRegistration;
+    /**
+     * Register this peer in the CadrePeer table.
+     * This allows other cadre members to discover this node.
+     */
+    private registerSelf;
+    private handleStrandAdded;
+    private handleStrandRemoved;
+    private cleanup;
+    private handleStrandIdle;
+    private handleStrandHibernate;
+    private handleStrandWake;
+    /**
+     * Add a strand with its sApp configuration.
+     * The hosting application must provide the sApp schema when creating a strand.
+     */
+    addStrand(config: StrandConfig): Promise<StrandInstance>;
+    /**
+     * Remove a strand
+     */
+    removeStrand(strandId: string): Promise<void>;
+    /**
+     * Record activity on a strand (resets hibernation timer)
+     */
+    recordStrandActivity(strandId: string): void;
+    /**
+     * Force wake a hibernating strand
+     */
+    wakeStrand(strandId: string): Promise<void>;
+    /**
+     * Get the control network node (for advanced use)
+     */
+    getControlNode(): Libp2p | null;
+    /**
+     * Get the control database (for advanced queries)
+     */
+    getControlDatabase(): ControlDatabase | null;
+    /**
+     * Force a poll of the strand watcher (for testing)
+     */
+    forceStrandPoll(): Promise<void>;
+    /**
+     * Get the sApp configuration for a strand
+     */
+    getSAppConfig(strandId: string): SAppConfig | undefined;
+    /**
+     * Initialize the seed bootstrap service with an authority key.
+     * Must be called before using seed-related methods that require signing.
+     *
+     * @param authorityPrivateKey - The authority's private key (base64url encoded)
+     */
+    initializeSeedBootstrap(authorityPrivateKey: string): void;
+    /**
+     * Enable the seed listener for receiving seeds via the /sereus/seed/1.0.0 protocol.
+     * This is for drone nodes that need to receive seeds without being an authority.
+     * Does not require an authority key.
+     */
+    enableSeedListener(): void;
+    /**
+     * Get the seed bootstrap service (for advanced use)
+     */
+    getSeedBootstrapService(): SeedBootstrapService | null;
+    /**
+     * Authorize a new peer to join the cadre.
+     * Signs the peer ID with the authority key and inserts into CadrePeer table.
+     *
+     * @param peerId - The peer ID to authorize
+     * @param multiaddrs - Optional multiaddrs for the peer
+     */
+    authorizePeer(peerId: string, multiaddrs?: string[]): Promise<void>;
+    /**
+     * Create a seed from the current control network state.
+     * The seed contains peer information and is signed by an authority.
+     */
+    createSeed(): Promise<ControlNetworkSeed>;
+    /**
+     * Apply a seed to populate the peer cache and enable connections.
+     * Validates the seed signature before applying.
+     */
+    applySeed(seed: ControlNetworkSeed): Promise<ApplySeedResult>;
+    /**
+     * Deliver a seed directly to a peer via the /sereus/seed/1.0.0 protocol.
+     */
+    deliverSeed(targetMultiaddr: string, seed: ControlNetworkSeed): Promise<{
+        accepted: boolean;
+        reason?: string;
+    }>;
+    /**
+     * Encode a seed for out-of-band delivery (e.g., QR code, copy/paste).
+     */
+    encodeSeed(seed: ControlNetworkSeed): string;
+    /**
+     * Decode a seed from base64url encoding.
+     */
+    decodeSeed(encoded: string): ControlNetworkSeed;
+    /**
+     * Get this node's circuit relay address for inclusion in seeds.
+     * Returns null if no relay address is available.
+     */
+    getRelayAddress(): Promise<string | null>;
+    /**
+     * Add a drone to the cadre (for phone/server adding provider-hosted node).
+     * Creates authorization and seed for drone initialization.
+     */
+    addDrone(options: AddDroneOptions): Promise<DroneInitResult>;
+    /**
+     * Create an invite for a phone to join the cadre.
+     * Use when a server wants to invite a NAT'd phone.
+     */
+    createInvite(token?: string, expiresIn?: number): Promise<InviteResult>;
+    /**
+     * Accept a phone connection using an invite.
+     * Call this when a phone dials in with an invite token.
+     */
+    acceptPhone(options: AddPhoneOptions, issuedInvite?: CadreInvite): Promise<void>;
+    /**
+     * Add a phone to the cadre with relay support.
+     * Use when both nodes are NAT'd (phone-to-phone).
+     */
+    addPhoneWithRelay(phonePeerId: string): Promise<DroneInitResult>;
+    /**
+     * Encode an invite for out-of-band delivery (QR, link, etc.).
+     */
+    encodeInvite(invite: CadreInvite): string;
+    /**
+     * Decode an invite from base64url encoding.
+     */
+    decodeInvite(encoded: string): CadreInvite;
+    /**
+     * Dial an authority from an invite (for phone joining via invite).
+     */
+    dialInvite(invite: CadreInvite): Promise<void>;
+    /**
+     * Initialize the strand solicitation service.
+     * This enables forming strands with other parties via open invitations.
+     *
+     * @param options - Configuration for the solicitation service
+     */
+    initializeStrandSolicitation(options?: StrandSolicitationServiceOptions): void;
+    /**
+     * Get the strand solicitation service (for advanced use)
+     */
+    getStrandSolicitationService(): StrandSolicitationService | null;
+    /**
+     * Create an open invitation for others to form strands with this party.
+     *
+     * @param sAppId - The sApp to use for formed strands
+     * @param expirationMs - How long the invitation is valid (ms from now)
+     * @returns The open invitation to share out-of-band
+     */
+    createOpenInvitation(sAppId: string, expirationMs?: number): Promise<OpenInvitation>;
+    /**
+     * Form a strand with a responder via an open invitation.
+     *
+     * @param invitation - The open invitation received out-of-band
+     * @param disclosure - Identity/context information to share with the responder
+     * @returns The member key and strand info if successful
+     */
+    formStrand(invitation: OpenInvitation, disclosure?: StrandFormationDisclosure): Promise<FormStrandResult>;
+    /**
+     * Encode an open invitation for out-of-band delivery (QR, link, etc.).
+     */
+    encodeInvitation(invitation: OpenInvitation): string;
+    /**
+     * Decode an open invitation from base64url encoding.
+     */
+    decodeInvitation(encoded: string): OpenInvitation;
+}
+export {};