reflow_network 0.2.1

Network executor for Reflow — routes messages between actors, manages subgraphs, and emits runtime events.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

<!DOCTYPE html>
<html>
<head>
    <title>State Sharing Test - JavaScript ↔ Rust WASM</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 800px;
            margin: 0 auto;
            padding: 20px;
        }
        .test-section {
            border: 1px solid #ccc;
            margin: 20px 0;
            padding: 15px;
            border-radius: 5px;
        }
        .success {
            background-color: #d4edda;
            border-color: #c3e6cb;
        }
        .error {
            background-color: #f8d7da;
            border-color: #f5c6cb;
        }
        button {
            background-color: #007bff;
            color: white;
            border: none;
            padding: 10px 15px;
            margin: 5px;
            border-radius: 3px;
            cursor: pointer;
        }
        button:hover {
            background-color: #0056b3;
        }
        .state-display {
            background-color: #f8f9fa;
            border: 1px solid #dee2e6;
            padding: 10px;
            margin: 10px 0;
            border-radius: 3px;
            font-family: monospace;
        }
    </style>
</head>
<body>
    <h1>State Sharing Test: JavaScript ↔ Rust WASM</h1>
    <p>This test demonstrates that JavaScript and Rust now properly share state through the WASM bridge.</p>

    <div class="test-section">
        <h2>Test Actor</h2>
        <p>Current state:</p>
        <div id="state-display" class="state-display">Loading...</div>
        
        <button onclick="setFromJS()">Set from JavaScript</button>
        <button onclick="runActor()">Run Actor (Rust)</button>
        <button onclick="getState()">Refresh State Display</button>
        <button onclick="clearState()">Clear State</button>
    </div>

    <div class="test-section">
        <h2>Test Results</h2>
        <div id="test-results"></div>
    </div>

    <script type="module">
        import init, { JsWasmActor } from '../pkg/reflow_network.js';

        let wasmActor = null;
        let testResults = [];

        // Initialize WASM
        await init();

        // Create a test actor
        class TestActor {
            constructor() {
                this.inports = ['input'];
                this.outports = ['output'];
                this.config = { test: true };
            }

            run(context) {
                console.log('Actor running with context:', context);
                
                // Read current state
                const currentCount = context.state.get('count') || 0;
                const currentMessage = context.state.get('message') || '';
                
                // Modify state from Rust side
                context.state.set('count', currentCount + 1);
                context.state.set('message', `Updated from Rust at ${new Date().toLocaleTimeString()}`);
                context.state.set('lastUpdatedBy', 'Rust');
                
                // Send output
                context.send({
                    output: {
                        count: currentCount + 1,
                        message: 'Processed by Rust actor'
                    }
                });
                
                addTestResult('✅ Actor executed successfully', 'success');
                updateStateDisplay();
            }
        }

        // Create WASM actor wrapper
        const testActor = new TestActor();
        wasmActor = new JsWasmActor(testActor);

        // Make functions global for button clicks
        window.setFromJS = function() {
            if (!wasmActor) return;
            
            // Get current state handle
            const currentState = wasmActor.getState();
            if (currentState) {
                const count = currentState.get('count') || 0;
                currentState.set('count', count + 10);
                currentState.set('message', `Updated from JavaScript at ${new Date().toLocaleTimeString()}`);
                currentState.set('lastUpdatedBy', 'JavaScript');
                
                addTestResult('✅ State updated from JavaScript', 'success');
                updateStateDisplay();
            } else {
                addTestResult('❌ Could not access state from JavaScript', 'error');
            }
        };

        window.runActor = function() {
            if (!wasmActor) return;
            
            try {
                // Send a message to the actor
                wasmActor.sendMessage('input', { 
                    action: 'increment',
                    timestamp: Date.now()
                });
                
                addTestResult('✅ Message sent to actor', 'success');
            } catch (error) {
                addTestResult(`❌ Error running actor: ${error.message}`, 'error');
            }
        };

        window.getState = function() {
            updateStateDisplay();
        };

        window.clearState = function() {
            if (!wasmActor) return;
            
            const currentState = wasmActor.getState();
            if (currentState) {
                currentState.clear();
                addTestResult('✅ State cleared', 'success');
                updateStateDisplay();
            }
        };

        function updateStateDisplay() {
            if (!wasmActor) return;
            
            const currentState = wasmActor.getState();
            const stateDisplay = document.getElementById('state-display');
            
            if (currentState) {
                const stateObj = currentState.getAll();
                stateDisplay.textContent = JSON.stringify(stateObj, null, 2);
            } else {
                stateDisplay.textContent = 'No state available';
            }
        }

        function addTestResult(message, type) {
            testResults.push({ message, type, timestamp: new Date().toLocaleTimeString() });
            
            const resultsDiv = document.getElementById('test-results');
            resultsDiv.innerHTML = testResults.map(result => 
                `<div class="test-section ${result.type}">
                    [${result.timestamp}] ${result.message}
                </div>`
            ).join('');
        }

        // Initial state display
        updateStateDisplay();
        addTestResult('🚀 Test initialized successfully', 'success');
    </script>
</body>
</html>