@agentshouse/mdruntime-adapter 0.1.0-cf41d9210cb6b → 0.1.0-cf75412975d5b
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/actions.d.ts +2 -52
- package/dist/actions.d.ts.map +1 -1
- package/dist/actions.js +7 -225
- package/dist/adapter.d.ts.map +1 -1
- package/dist/adapter.js +75 -214
- package/dist/discovery.d.ts +17 -3
- package/dist/discovery.d.ts.map +1 -1
- package/dist/discovery.js +58 -22
- package/dist/history.d.ts +12 -0
- package/dist/history.d.ts.map +1 -0
- package/dist/history.js +92 -0
- package/dist/house-model.d.ts +910 -1
- package/dist/house-model.d.ts.map +1 -1
- package/dist/house-model.js +496 -489
- package/dist/index.d.ts +6 -3
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +6 -3
- package/dist/model.d.ts +1 -2
- package/dist/model.d.ts.map +1 -1
- package/dist/model.js +0 -17
- package/dist/read.d.ts +5 -44
- package/dist/read.d.ts.map +1 -1
- package/dist/read.js +30 -175
- package/dist/refusal.d.ts +0 -3
- package/dist/refusal.d.ts.map +1 -1
- package/dist/refusal.js +0 -5
- package/dist/room-stream.d.ts +1 -0
- package/dist/room-stream.d.ts.map +1 -1
- package/dist/room-stream.js +23 -2
- package/dist/room-types.d.ts +2 -2
- package/dist/room-types.d.ts.map +1 -1
- package/dist/room-types.js +6 -6
- package/dist/search.d.ts +5 -0
- package/dist/search.d.ts.map +1 -0
- package/dist/search.js +47 -0
- package/dist/site.d.ts.map +1 -1
- package/dist/site.js +54 -90
- package/dist/stream.d.ts +13 -14
- package/dist/stream.d.ts.map +1 -1
- package/dist/stream.js +168 -429
- package/dist/transport.d.ts +38 -34
- package/dist/transport.d.ts.map +1 -1
- package/dist/transport.js +54 -12
- package/dist/upload.d.ts.map +1 -1
- package/dist/upload.js +2 -2
- package/dist/write.d.ts +2 -1
- package/dist/write.d.ts.map +1 -1
- package/dist/write.js +7 -17
- package/package.json +2 -2
- package/dist/gather.d.ts +0 -3
- package/dist/gather.d.ts.map +0 -1
- package/dist/gather.js +0 -35
package/dist/stream.js
CHANGED
|
@@ -1,109 +1,98 @@
|
|
|
1
|
-
import { ROW_WEIGHT, } from '@agentshouse/mdruntime';
|
|
2
|
-
import { acceptedMessage, cursorPosition } from './
|
|
3
|
-
import {
|
|
4
|
-
import { answered, answering, binaryFileOf, folded, forgotten, headChange, revised, } from './read.js';
|
|
5
|
-
import {
|
|
6
|
-
|
|
1
|
+
import { ROW_WEIGHT, stepped, } from '@agentshouse/mdruntime';
|
|
2
|
+
import { acceptedMessage, cursorPosition, houseHistory } from './history.js';
|
|
3
|
+
import { streamedModels } from './model.js';
|
|
4
|
+
import { answered, answering, binaryFileOf, folded, forgotten, headChange, outlineOf, revised, } from './read.js';
|
|
5
|
+
import { houseDoorRoute, } from './transport.js';
|
|
6
|
+
import { DECIMAL, roomVersion } from './version.js';
|
|
7
7
|
function turnOperation(frame) {
|
|
8
8
|
const { type: _type, conversation_id: _conversation, turn_id: _turn, ...operation } = frame;
|
|
9
9
|
return structuredClone(operation);
|
|
10
10
|
}
|
|
11
|
+
async function houseAgents(transport) {
|
|
12
|
+
const answer = await transport.door(houseDoorRoute('agents/read'), {});
|
|
13
|
+
const agents = answer.status === 200 ? answer.body?.agents : null;
|
|
14
|
+
if (!Array.isArray(agents))
|
|
15
|
+
return null;
|
|
16
|
+
return agents.flatMap((one) => {
|
|
17
|
+
const { id, name, retired_at: retired } = (one ?? {});
|
|
18
|
+
return typeof id === 'string' && typeof name === 'string'
|
|
19
|
+
? [{ agent: id, name, retired: retired !== null && retired !== undefined }]
|
|
20
|
+
: [];
|
|
21
|
+
});
|
|
22
|
+
}
|
|
11
23
|
function listedConversation(listed) {
|
|
12
24
|
return {
|
|
13
25
|
conversation: listed.conversation_id,
|
|
14
26
|
agent: listed.agent_id,
|
|
27
|
+
agentName: listed.agent_name,
|
|
28
|
+
agentRetired: listed.agent_retired,
|
|
15
29
|
name: listed.name,
|
|
16
30
|
created: listed.created_at,
|
|
17
31
|
finished: listed.finished_at,
|
|
18
32
|
outcome: listed.outcome,
|
|
19
33
|
waiting: listed.waiting,
|
|
20
34
|
newest: listed.newest === null ? null : cursorPosition(listed.newest),
|
|
35
|
+
processEnded: listed.process_ended_at,
|
|
21
36
|
};
|
|
22
37
|
}
|
|
23
38
|
function position(value) {
|
|
24
|
-
if (
|
|
39
|
+
if (!DECIMAL.test(value))
|
|
25
40
|
return null;
|
|
26
41
|
return BigInt(value);
|
|
27
42
|
}
|
|
28
|
-
function
|
|
29
|
-
const
|
|
30
|
-
let open = null;
|
|
43
|
+
function* changed(tracked, entries, version, schemas) {
|
|
44
|
+
const answer = answering();
|
|
31
45
|
for (const entry of entries) {
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
}
|
|
37
|
-
else {
|
|
38
|
-
if (open !== null)
|
|
39
|
-
return null;
|
|
40
|
-
if (entry.continued !== true) {
|
|
41
|
-
whole.push(entry);
|
|
42
|
-
continue;
|
|
43
|
-
}
|
|
44
|
-
if (entry.text === undefined)
|
|
45
|
-
return null;
|
|
46
|
-
open = { entry, texts: [entry.text] };
|
|
46
|
+
yield ROW_WEIGHT + (entry.text?.length ?? 0);
|
|
47
|
+
if (entry.kind === 'folder') {
|
|
48
|
+
folded(answer, entry.path, entry.removed === true);
|
|
49
|
+
continue;
|
|
47
50
|
}
|
|
48
|
-
if (entry.
|
|
51
|
+
if (entry.path === tracked.schema)
|
|
52
|
+
schemas.set(entry.path, entry);
|
|
53
|
+
forgotten(answer, entry.path);
|
|
54
|
+
if (entry.kind === 'removed') {
|
|
55
|
+
answer.removals.add(entry.path);
|
|
49
56
|
continue;
|
|
50
|
-
const { continued: _continued, ...head } = open.entry;
|
|
51
|
-
whole.push({ ...head, text: open.texts.join('') });
|
|
52
|
-
open = null;
|
|
53
|
-
}
|
|
54
|
-
return open === null ? whole : null;
|
|
55
|
-
}
|
|
56
|
-
async function verified(entries) {
|
|
57
|
-
try {
|
|
58
|
-
for (const entry of entries) {
|
|
59
|
-
if (entry.text === undefined || entry.sha256 === undefined)
|
|
60
|
-
continue;
|
|
61
|
-
if ((await sha256Hex(entry.text)) !== entry.sha256)
|
|
62
|
-
return false;
|
|
63
57
|
}
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
58
|
+
const binary = binaryFileOf(entry);
|
|
59
|
+
const outline = entry.text === undefined ? outlineOf(entry.outline) : undefined;
|
|
60
|
+
if (binary !== undefined) {
|
|
61
|
+
if (binary !== null)
|
|
62
|
+
answer.binaryFiles.set(entry.path, binary);
|
|
63
|
+
}
|
|
64
|
+
else if (outline !== undefined && outline !== null)
|
|
65
|
+
answer.outlines.set(entry.path, outline);
|
|
66
|
+
else
|
|
67
|
+
answer.documents.set(entry.path, entry.text ?? '');
|
|
68
|
+
const revision = entry.revision ?? binary?.sha256 ?? entry.sha256;
|
|
69
|
+
if (revision !== undefined)
|
|
70
|
+
revised(answer, entry.path, revision);
|
|
71
|
+
const head = headChange(entry);
|
|
72
|
+
if (head)
|
|
73
|
+
answer.changes.set(entry.path, head);
|
|
68
74
|
}
|
|
75
|
+
return { kind: 'net-advancement', roomVersion: version, ...(yield* answered(answer)) };
|
|
69
76
|
}
|
|
70
|
-
function
|
|
71
|
-
const
|
|
72
|
-
const
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
const text = last.text?.length ?? 0;
|
|
76
|
-
if (last.kind !== 'piece') {
|
|
77
|
-
return last.sha256 === undefined
|
|
78
|
-
? kept.resume
|
|
79
|
-
: { ...point, handled: frame.handled, piece: { sha256: last.sha256, offset: text } };
|
|
80
|
-
}
|
|
81
|
-
const piece = kept.resume?.piece ?? null;
|
|
82
|
-
if (piece === null)
|
|
83
|
-
return kept.resume;
|
|
84
|
-
const pieces = frame.entries.reduce((sum, entry) => sum + (entry.kind === 'piece' ? (entry.text?.length ?? 0) : 0), 0);
|
|
85
|
-
return {
|
|
86
|
-
...point,
|
|
87
|
-
handled: frame.handled,
|
|
88
|
-
piece: { sha256: piece.sha256, offset: piece.offset + pieces },
|
|
89
|
-
};
|
|
77
|
+
async function changePage(tracked, entries, version, mode) {
|
|
78
|
+
const schemas = new Map();
|
|
79
|
+
const page = await stepped(changed(tracked, entries, version, schemas));
|
|
80
|
+
const models = await streamedModels(schemas, tracked, mode);
|
|
81
|
+
return models === undefined ? page : { ...page, models };
|
|
90
82
|
}
|
|
91
|
-
export function houseNotifications(transport, mode) {
|
|
83
|
+
export function houseNotifications(transport, mode, discovering) {
|
|
92
84
|
const stream = transport.stream;
|
|
93
|
-
const
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
let loaded = Promise.resolve();
|
|
97
|
-
let acknowledging = null;
|
|
98
|
-
let receiving = Promise.resolve();
|
|
99
|
-
let verifying = 0;
|
|
100
|
-
const locators = new Map();
|
|
85
|
+
const staged = new Map();
|
|
86
|
+
let socket = null;
|
|
87
|
+
const tracking = new Map();
|
|
101
88
|
const observers = new Set();
|
|
102
89
|
const conversationObservers = new Set();
|
|
103
90
|
const modeObservers = new Set();
|
|
104
91
|
let replicated = [];
|
|
92
|
+
let listedCursor = null;
|
|
105
93
|
const live = new Set();
|
|
106
94
|
let opening = null;
|
|
95
|
+
let announced = null;
|
|
107
96
|
const runtime = crypto.randomUUID();
|
|
108
97
|
function emit(event) {
|
|
109
98
|
for (const observer of observers)
|
|
@@ -116,6 +105,7 @@ export function houseNotifications(transport, mode) {
|
|
|
116
105
|
event.kind === 'commands' ||
|
|
117
106
|
event.kind === 'options' ||
|
|
118
107
|
event.kind === 'starting' ||
|
|
108
|
+
event.kind === 'subagents' ||
|
|
119
109
|
event.kind === 'link' ||
|
|
120
110
|
event.kind === 'deliveries') {
|
|
121
111
|
live.add(event.conversation);
|
|
@@ -125,12 +115,31 @@ export function houseNotifications(transport, mode) {
|
|
|
125
115
|
}
|
|
126
116
|
function reopened(next) {
|
|
127
117
|
opening = next;
|
|
128
|
-
|
|
118
|
+
announced = null;
|
|
119
|
+
socket = next;
|
|
120
|
+
staged.clear();
|
|
129
121
|
const gapped = new Set([...replicated, ...live]);
|
|
130
122
|
live.clear();
|
|
131
123
|
for (const conversation of gapped)
|
|
132
124
|
emitConversation({ kind: 'gap', conversation });
|
|
133
125
|
emit({ kind: 'opened' });
|
|
126
|
+
if (mode === 'site')
|
|
127
|
+
announce(next, null);
|
|
128
|
+
}
|
|
129
|
+
function announce(via, frame) {
|
|
130
|
+
void discovering.opened(frame).then((discovery) => {
|
|
131
|
+
if (socket !== via)
|
|
132
|
+
return;
|
|
133
|
+
if (discovery === null) {
|
|
134
|
+
via.close();
|
|
135
|
+
return;
|
|
136
|
+
}
|
|
137
|
+
announced = { kind: 'discovered', discovery };
|
|
138
|
+
emit(announced);
|
|
139
|
+
}, () => {
|
|
140
|
+
if (socket === via)
|
|
141
|
+
via.close();
|
|
142
|
+
});
|
|
134
143
|
}
|
|
135
144
|
function converse(frame) {
|
|
136
145
|
const conversation = frame.conversation_id;
|
|
@@ -149,6 +158,7 @@ export function houseNotifications(transport, mode) {
|
|
|
149
158
|
return;
|
|
150
159
|
emitConversation({ kind: 'commands', conversation, commands: [] });
|
|
151
160
|
emitConversation({ kind: 'options', conversation, options: [] });
|
|
161
|
+
emitConversation({ kind: 'subagents', conversation, subagents: [] });
|
|
152
162
|
return;
|
|
153
163
|
}
|
|
154
164
|
if (frame.type === 'commands') {
|
|
@@ -167,6 +177,14 @@ export function houseNotifications(transport, mode) {
|
|
|
167
177
|
emitConversation({ kind: 'starting', conversation, step: frame.step });
|
|
168
178
|
return;
|
|
169
179
|
}
|
|
180
|
+
if (frame.type === 'subagents') {
|
|
181
|
+
emitConversation({
|
|
182
|
+
kind: 'subagents',
|
|
183
|
+
conversation,
|
|
184
|
+
subagents: structuredClone(frame.subagents),
|
|
185
|
+
});
|
|
186
|
+
return;
|
|
187
|
+
}
|
|
170
188
|
if (frame.type === 'link') {
|
|
171
189
|
emitConversation({ kind: 'link', conversation, connected: frame.connected });
|
|
172
190
|
return;
|
|
@@ -188,171 +206,30 @@ export function houseNotifications(transport, mode) {
|
|
|
188
206
|
return;
|
|
189
207
|
emitConversation({ kind: 'accepted-message', conversation, message });
|
|
190
208
|
}
|
|
191
|
-
function
|
|
192
|
-
const
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
}
|
|
196
|
-
}
|
|
197
|
-
function interrupt(authority) {
|
|
198
|
-
const line = lines.get(authority);
|
|
199
|
-
if (line !== undefined)
|
|
200
|
-
lines.set(authority, { ...line, frames: [] });
|
|
201
|
-
}
|
|
202
|
-
async function forget(carries) {
|
|
203
|
-
const held = carries.filter((carry) => kept.delete(carry));
|
|
204
|
-
if (held.length > 0)
|
|
205
|
-
await receipts?.drop(held).catch(() => { });
|
|
206
|
-
}
|
|
207
|
-
async function lost(authority, carry) {
|
|
208
|
-
interrupt(authority);
|
|
209
|
-
await forget([carry]);
|
|
210
|
-
}
|
|
211
|
-
async function stage(frame, via) {
|
|
212
|
-
await loaded;
|
|
213
|
-
const port = receipts;
|
|
214
|
-
if (port === null)
|
|
215
|
-
return;
|
|
216
|
-
const held = kept.get(frame.carry);
|
|
217
|
-
if (held === undefined && frame.index !== 0) {
|
|
218
|
-
interrupt(frame.authority);
|
|
219
|
-
return;
|
|
220
|
-
}
|
|
221
|
-
if (held !== undefined &&
|
|
222
|
-
(held.fenced !== null || frame.index > held.parts || frame.index < (held.resume?.parts ?? 0))) {
|
|
223
|
-
await lost(frame.authority, frame.carry);
|
|
209
|
+
function stage(frame, via) {
|
|
210
|
+
const held = staged.get(frame.carry);
|
|
211
|
+
if (frame.index !== (held?.parts ?? 0)) {
|
|
212
|
+
staged.delete(frame.carry);
|
|
224
213
|
return;
|
|
225
214
|
}
|
|
226
215
|
if (held === undefined) {
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
const start = held ?? {
|
|
232
|
-
authority: frame.authority,
|
|
233
|
-
carry: frame.carry,
|
|
234
|
-
logEpoch: lines.get(frame.authority)?.logEpoch ?? null,
|
|
235
|
-
after: frame.after,
|
|
236
|
-
parts: 0,
|
|
237
|
-
resume: null,
|
|
238
|
-
fenced: null,
|
|
239
|
-
};
|
|
240
|
-
const next = { ...start, parts: frame.index + 1, resume: resumed(start, frame) };
|
|
241
|
-
const part = { entries: frame.entries };
|
|
242
|
-
try {
|
|
243
|
-
await port.keep(frame.carry, next, { index: frame.index, value: part });
|
|
244
|
-
}
|
|
245
|
-
catch {
|
|
246
|
-
await lost(frame.authority, frame.carry);
|
|
247
|
-
return;
|
|
216
|
+
for (const [carry, other] of staged) {
|
|
217
|
+
if (other.authority === frame.authority)
|
|
218
|
+
staged.delete(carry);
|
|
219
|
+
}
|
|
248
220
|
}
|
|
249
|
-
|
|
221
|
+
const next = held ?? { authority: frame.authority, parts: 0, entries: [] };
|
|
222
|
+
next.entries.push(...frame.entries);
|
|
223
|
+
next.parts += 1;
|
|
224
|
+
staged.set(frame.carry, next);
|
|
250
225
|
via?.received(frame.authority, frame.carry, frame.index);
|
|
251
226
|
}
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
if (
|
|
256
|
-
return null;
|
|
257
|
-
const read = (await receipts.parts(carry, parts));
|
|
258
|
-
if (read.length !== parts)
|
|
259
|
-
return null;
|
|
260
|
-
const entries = assembled(read.flatMap((part) => part.entries));
|
|
261
|
-
return entries !== null && (await verified(entries)) ? entries : null;
|
|
262
|
-
}
|
|
263
|
-
async function carried(frame) {
|
|
264
|
-
await loaded;
|
|
265
|
-
const held = kept.get(frame.carry);
|
|
266
|
-
if (frame.parts > 0 && held?.parts !== frame.parts) {
|
|
267
|
-
await lost(frame.authority, frame.carry);
|
|
268
|
-
return;
|
|
269
|
-
}
|
|
270
|
-
const entries = await keptEntries(frame.carry, frame.parts).catch(() => null);
|
|
271
|
-
if (entries === null) {
|
|
272
|
-
await lost(frame.authority, frame.carry);
|
|
227
|
+
function carried(frame) {
|
|
228
|
+
const held = staged.get(frame.carry);
|
|
229
|
+
staged.delete(frame.carry);
|
|
230
|
+
if ((held?.parts ?? 0) !== frame.parts)
|
|
273
231
|
return;
|
|
274
|
-
|
|
275
|
-
const fenced = {
|
|
276
|
-
...(held ?? {
|
|
277
|
-
authority: frame.authority,
|
|
278
|
-
carry: frame.carry,
|
|
279
|
-
logEpoch: frame.log_epoch,
|
|
280
|
-
after: frame.after,
|
|
281
|
-
parts: 0,
|
|
282
|
-
resume: null,
|
|
283
|
-
}),
|
|
284
|
-
after: frame.after,
|
|
285
|
-
fenced: { position: frame.position, logEpoch: frame.log_epoch },
|
|
286
|
-
};
|
|
287
|
-
try {
|
|
288
|
-
await receipts?.keep(frame.carry, fenced);
|
|
289
|
-
}
|
|
290
|
-
catch {
|
|
291
|
-
await lost(frame.authority, frame.carry);
|
|
292
|
-
return;
|
|
293
|
-
}
|
|
294
|
-
kept.set(frame.carry, fenced);
|
|
295
|
-
publish(frame, entries);
|
|
296
|
-
}
|
|
297
|
-
async function load(port) {
|
|
298
|
-
try {
|
|
299
|
-
for (const { key, head } of await port.heads())
|
|
300
|
-
kept.set(key, head);
|
|
301
|
-
}
|
|
302
|
-
catch {
|
|
303
|
-
kept.clear();
|
|
304
|
-
}
|
|
305
|
-
}
|
|
306
|
-
async function restored(room) {
|
|
307
|
-
const line = lines.get(room.authority);
|
|
308
|
-
let at = room.position;
|
|
309
|
-
const chain = [];
|
|
310
|
-
for (;;) {
|
|
311
|
-
const next = [...kept.values()].find((carry) => carry.authority === room.authority &&
|
|
312
|
-
carry.after === at &&
|
|
313
|
-
carry.fenced?.logEpoch === room.log_epoch);
|
|
314
|
-
if (next?.fenced == null)
|
|
315
|
-
break;
|
|
316
|
-
const entries = await keptEntries(next.carry, next.parts).catch(() => null);
|
|
317
|
-
if (entries === null)
|
|
318
|
-
break;
|
|
319
|
-
chain.push({ carry: next, entries });
|
|
320
|
-
at = next.fenced.position;
|
|
321
|
-
}
|
|
322
|
-
const partial = [...kept.values()].find((carry) => carry.authority === room.authority &&
|
|
323
|
-
carry.fenced === null &&
|
|
324
|
-
carry.logEpoch === room.log_epoch &&
|
|
325
|
-
carry.after === at &&
|
|
326
|
-
carry.resume !== null &&
|
|
327
|
-
carry.resume.parts > 0);
|
|
328
|
-
const stale = [...kept.values()].filter((carry) => carry.authority === room.authority &&
|
|
329
|
-
carry !== partial &&
|
|
330
|
-
!chain.some((link) => link.carry === carry));
|
|
331
|
-
await forget(stale.map((carry) => carry.carry));
|
|
332
|
-
if (line !== undefined && line.logEpoch === room.log_epoch && chain.length > 0) {
|
|
333
|
-
const frames = chain.map(({ carry, entries }) => ({
|
|
334
|
-
after: BigInt(carry.after),
|
|
335
|
-
position: BigInt(carry.fenced.position),
|
|
336
|
-
entries,
|
|
337
|
-
}));
|
|
338
|
-
lines.set(room.authority, { ...line, frames: [...line.frames, ...frames] });
|
|
339
|
-
}
|
|
340
|
-
return {
|
|
341
|
-
...room,
|
|
342
|
-
position: at,
|
|
343
|
-
...(partial?.resume == null
|
|
344
|
-
? {}
|
|
345
|
-
: {
|
|
346
|
-
carry: {
|
|
347
|
-
id: partial.carry,
|
|
348
|
-
parts: partial.resume.parts,
|
|
349
|
-
from: partial.resume.from,
|
|
350
|
-
target: partial.resume.target,
|
|
351
|
-
handled: partial.resume.handled,
|
|
352
|
-
...(partial.resume.piece === null ? {} : { piece: partial.resume.piece }),
|
|
353
|
-
},
|
|
354
|
-
}),
|
|
355
|
-
};
|
|
232
|
+
publish(frame, held?.entries ?? []);
|
|
356
233
|
}
|
|
357
234
|
function handle(frame, via) {
|
|
358
235
|
if (frame.type === 'signal') {
|
|
@@ -364,18 +241,31 @@ export function houseNotifications(transport, mode) {
|
|
|
364
241
|
return;
|
|
365
242
|
}
|
|
366
243
|
if (frame.type === 'opening') {
|
|
244
|
+
if (via !== null && mode === 'credential')
|
|
245
|
+
announce(via, frame);
|
|
246
|
+
return;
|
|
247
|
+
}
|
|
248
|
+
if (frame.type === 'caught_up') {
|
|
367
249
|
emit({
|
|
368
|
-
kind: '
|
|
369
|
-
expired: frame.expired.flatMap((authority) =>
|
|
250
|
+
kind: 'caught-up',
|
|
251
|
+
expired: frame.expired.flatMap((authority) => (tracking.get(authority) ?? []).map((tracked) => tracked.locator)),
|
|
370
252
|
});
|
|
371
253
|
return;
|
|
372
254
|
}
|
|
373
255
|
if (frame.type === 'authority_changed') {
|
|
374
|
-
|
|
256
|
+
const change = discovering.changed(frame);
|
|
257
|
+
if (change !== null)
|
|
258
|
+
emit(change);
|
|
375
259
|
return;
|
|
376
260
|
}
|
|
377
261
|
if (frame.type === 'conversations') {
|
|
378
|
-
emitConversation({
|
|
262
|
+
emitConversation({
|
|
263
|
+
kind: 'list',
|
|
264
|
+
entries: frame.conversations.map(listedConversation),
|
|
265
|
+
whole: frame.whole,
|
|
266
|
+
more: frame.more,
|
|
267
|
+
cursor: frame.cursor,
|
|
268
|
+
});
|
|
379
269
|
return;
|
|
380
270
|
}
|
|
381
271
|
if (frame.type === 'conversation') {
|
|
@@ -391,6 +281,7 @@ export function houseNotifications(transport, mode) {
|
|
|
391
281
|
frame.type === 'commands' ||
|
|
392
282
|
frame.type === 'options' ||
|
|
393
283
|
frame.type === 'starting' ||
|
|
284
|
+
frame.type === 'subagents' ||
|
|
394
285
|
frame.type === 'link' ||
|
|
395
286
|
frame.type === 'deliveries' ||
|
|
396
287
|
frame.type === 'interactions' ||
|
|
@@ -399,60 +290,35 @@ export function houseNotifications(transport, mode) {
|
|
|
399
290
|
return;
|
|
400
291
|
}
|
|
401
292
|
if (frame.type === 'part')
|
|
402
|
-
|
|
403
|
-
if (frame.type === 'carried')
|
|
404
|
-
|
|
405
|
-
}
|
|
406
|
-
function ahead(work) {
|
|
407
|
-
return receipts === null ? work() : receipts.ahead(work);
|
|
293
|
+
stage(frame, via);
|
|
294
|
+
else if (frame.type === 'carried')
|
|
295
|
+
carried(frame);
|
|
408
296
|
}
|
|
409
297
|
function publish(frame, entries) {
|
|
410
298
|
const at = position(frame.position);
|
|
411
299
|
const after = position(frame.after);
|
|
412
|
-
if (at === null || after === null || after >= at)
|
|
413
|
-
interrupt(frame.authority);
|
|
300
|
+
if (at === null || after === null || after >= at)
|
|
414
301
|
return;
|
|
415
|
-
}
|
|
416
|
-
const
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
const next = last !== undefined && after <= last.position ? [...line.frames, held] : [held];
|
|
425
|
-
lines.set(frame.authority, { ...line, frames: next.length > HELD_FRAMES_MAX ? [] : next });
|
|
426
|
-
}
|
|
427
|
-
else {
|
|
428
|
-
interrupt(frame.authority);
|
|
429
|
-
}
|
|
430
|
-
announce(frame.authority, { position: frame.position, logEpoch: frame.log_epoch });
|
|
431
|
-
}
|
|
432
|
-
stream.observe((frame) => {
|
|
433
|
-
const via = acknowledging;
|
|
434
|
-
if (verifying === 0) {
|
|
435
|
-
const handled = handle(frame, via);
|
|
436
|
-
if (handled === undefined)
|
|
437
|
-
return;
|
|
438
|
-
verifying += 1;
|
|
439
|
-
receiving = handled.finally(() => {
|
|
440
|
-
verifying -= 1;
|
|
302
|
+
const from = roomVersion({ position: frame.after, logEpoch: frame.log_epoch });
|
|
303
|
+
const version = roomVersion({ position: frame.position, logEpoch: frame.log_epoch });
|
|
304
|
+
for (const tracked of tracking.get(frame.authority) ?? []) {
|
|
305
|
+
emit({
|
|
306
|
+
kind: 'room-change',
|
|
307
|
+
locator: tracked.locator,
|
|
308
|
+
from,
|
|
309
|
+
roomVersion: version,
|
|
310
|
+
read: () => changePage(tracked, entries, version, mode),
|
|
441
311
|
});
|
|
442
|
-
return;
|
|
443
312
|
}
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
.then(() => handle(frame, via))
|
|
447
|
-
.finally(() => {
|
|
448
|
-
verifying -= 1;
|
|
449
|
-
});
|
|
450
|
-
});
|
|
313
|
+
}
|
|
314
|
+
stream.observe((frame) => handle(frame, socket));
|
|
451
315
|
stream.opened(reopened);
|
|
452
|
-
stream.closed(({ revoked, lost }) => {
|
|
316
|
+
stream.closed(({ revoked, lost, authorityChanged }) => {
|
|
453
317
|
opening = null;
|
|
454
|
-
|
|
455
|
-
|
|
318
|
+
announced = null;
|
|
319
|
+
socket = null;
|
|
320
|
+
staged.clear();
|
|
321
|
+
emit({ kind: 'closed', revoked, lost, authorityChanged });
|
|
456
322
|
});
|
|
457
323
|
return {
|
|
458
324
|
runtime,
|
|
@@ -468,23 +334,30 @@ export function houseNotifications(transport, mode) {
|
|
|
468
334
|
replicate(next) {
|
|
469
335
|
replicated = [...next];
|
|
470
336
|
},
|
|
337
|
+
hold(cursor) {
|
|
338
|
+
listedCursor = cursor;
|
|
339
|
+
},
|
|
471
340
|
observe(notify) {
|
|
472
341
|
conversationObservers.add(notify);
|
|
473
342
|
return () => {
|
|
474
343
|
conversationObservers.delete(notify);
|
|
475
344
|
};
|
|
476
345
|
},
|
|
346
|
+
...(mode === 'credential'
|
|
347
|
+
? {
|
|
348
|
+
agents: () => houseAgents(transport),
|
|
349
|
+
history: (request) => houseHistory(transport, request),
|
|
350
|
+
}
|
|
351
|
+
: {}),
|
|
477
352
|
},
|
|
478
|
-
observe(notify
|
|
353
|
+
observe(notify) {
|
|
479
354
|
observers.add(notify);
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
loaded = load(port);
|
|
483
|
-
}
|
|
484
|
-
if (opening !== null) {
|
|
355
|
+
const replayed = opening === null ? [] : [{ kind: 'opened' }, announced];
|
|
356
|
+
if (replayed.length > 0) {
|
|
485
357
|
queueMicrotask(() => {
|
|
486
|
-
|
|
487
|
-
|
|
358
|
+
for (const event of replayed)
|
|
359
|
+
if (event !== null && observers.has(notify))
|
|
360
|
+
notify(event);
|
|
488
361
|
});
|
|
489
362
|
}
|
|
490
363
|
return () => {
|
|
@@ -492,153 +365,19 @@ export function houseNotifications(transport, mode) {
|
|
|
492
365
|
};
|
|
493
366
|
},
|
|
494
367
|
send(rooms) {
|
|
495
|
-
for (const room of rooms) {
|
|
496
|
-
const line = lines.get(room.authority);
|
|
497
|
-
const held = position(room.position);
|
|
498
|
-
if (line === undefined || held === null || line.logEpoch !== room.log_epoch)
|
|
499
|
-
continue;
|
|
500
|
-
lines.set(room.authority, { ...line, frames: [], held });
|
|
501
|
-
}
|
|
502
|
-
const current = opening;
|
|
503
368
|
opening = null;
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
void loaded
|
|
507
|
-
.then(() => Promise.all(rooms.map(restored)))
|
|
508
|
-
.then((presented) => {
|
|
509
|
-
current.hold(presented, runtime);
|
|
510
|
-
for (const [index, room] of presented.entries()) {
|
|
511
|
-
if (room.position === rooms[index].position)
|
|
512
|
-
continue;
|
|
513
|
-
announce(room.authority, { position: room.position, logEpoch: room.log_epoch });
|
|
514
|
-
}
|
|
515
|
-
});
|
|
516
|
-
},
|
|
517
|
-
published(locator, at) {
|
|
518
|
-
const authority = [...locators].find(([, held]) => held.includes(locator))?.[0];
|
|
519
|
-
const reached = position(at.position);
|
|
520
|
-
if (authority === undefined || reached === null)
|
|
521
|
-
return;
|
|
522
|
-
void forget([...kept.values()]
|
|
523
|
-
.filter((carry) => carry.authority === authority &&
|
|
524
|
-
carry.fenced !== null &&
|
|
525
|
-
carry.fenced.logEpoch === at.logEpoch &&
|
|
526
|
-
BigInt(carry.fenced.position) <= reached)
|
|
527
|
-
.map((carry) => carry.carry));
|
|
528
|
-
},
|
|
529
|
-
reopen() {
|
|
530
|
-
const current = opening;
|
|
531
|
-
opening = null;
|
|
532
|
-
current?.close();
|
|
369
|
+
announced = null;
|
|
370
|
+
socket?.hold(rooms, runtime, listedCursor);
|
|
533
371
|
},
|
|
534
372
|
track(entries) {
|
|
535
|
-
|
|
373
|
+
tracking.clear();
|
|
536
374
|
for (const entry of entries) {
|
|
537
|
-
|
|
538
|
-
if (lines.get(entry.authority)?.logEpoch !== entry.logEpoch) {
|
|
539
|
-
lines.set(entry.authority, { logEpoch: entry.logEpoch, frames: [], held: null });
|
|
540
|
-
}
|
|
375
|
+
tracking.set(entry.authority, [...(tracking.get(entry.authority) ?? []), entry]);
|
|
541
376
|
}
|
|
542
|
-
for (const
|
|
543
|
-
if (!
|
|
544
|
-
|
|
377
|
+
for (const [carry, held] of staged) {
|
|
378
|
+
if (!tracking.has(held.authority))
|
|
379
|
+
staged.delete(carry);
|
|
545
380
|
}
|
|
546
|
-
void loaded.then(() => forget([...kept.values()]
|
|
547
|
-
.filter((carry) => !locators.has(carry.authority))
|
|
548
|
-
.map((carry) => carry.carry)));
|
|
549
|
-
},
|
|
550
|
-
reach(authority, at) {
|
|
551
|
-
const line = lines.get(authority);
|
|
552
|
-
const held = position(at.position);
|
|
553
|
-
if (line === undefined || held === null || line.logEpoch !== at.logEpoch)
|
|
554
|
-
return;
|
|
555
|
-
if (line.held !== null && held <= line.held)
|
|
556
|
-
return;
|
|
557
|
-
lines.set(authority, {
|
|
558
|
-
...line,
|
|
559
|
-
frames: line.frames.filter((frame) => frame.position > held),
|
|
560
|
-
held,
|
|
561
|
-
});
|
|
562
|
-
},
|
|
563
|
-
edited(tracked, from) {
|
|
564
|
-
const line = lines.get(tracked.authority);
|
|
565
|
-
const start = position(from.position);
|
|
566
|
-
if (line === undefined || start === null || line.logEpoch !== from.logEpoch)
|
|
567
|
-
return [];
|
|
568
|
-
return [
|
|
569
|
-
...new Set(line.frames
|
|
570
|
-
.filter((frame) => frame.position > start)
|
|
571
|
-
.flatMap((frame) => frame.entries.flatMap((entry) => entry.kind === 'edited' && entry.revision !== undefined ? [entry.path] : []))),
|
|
572
|
-
];
|
|
573
|
-
},
|
|
574
|
-
*advance(tracked, from, holds) {
|
|
575
|
-
const line = lines.get(tracked.authority);
|
|
576
|
-
const start = position(from.position);
|
|
577
|
-
if (line === undefined || start === null || line.logEpoch !== from.logEpoch)
|
|
578
|
-
return null;
|
|
579
|
-
const pending = line.frames.filter((frame) => frame.position > start);
|
|
580
|
-
const first = pending[0];
|
|
581
|
-
if (first === undefined || first.after > start)
|
|
582
|
-
return null;
|
|
583
|
-
const answer = answering();
|
|
584
|
-
const schemas = new Map();
|
|
585
|
-
for (const frame of pending) {
|
|
586
|
-
for (const entry of frame.entries) {
|
|
587
|
-
yield ROW_WEIGHT + (entry.text?.length ?? 0);
|
|
588
|
-
if (entry.kind === 'folder') {
|
|
589
|
-
folded(answer, entry.path, entry.removed === true);
|
|
590
|
-
continue;
|
|
591
|
-
}
|
|
592
|
-
if (entry.kind === 'edited' &&
|
|
593
|
-
entry.revision !== undefined &&
|
|
594
|
-
holds?.(entry.path, entry.revision) === true) {
|
|
595
|
-
forgotten(answer, entry.path);
|
|
596
|
-
continue;
|
|
597
|
-
}
|
|
598
|
-
if (entry.path === tracked.schema)
|
|
599
|
-
schemas.set(entry.path, entry);
|
|
600
|
-
if (entry.kind === 'removed') {
|
|
601
|
-
forgotten(answer, entry.path);
|
|
602
|
-
answer.removals.add(entry.path);
|
|
603
|
-
continue;
|
|
604
|
-
}
|
|
605
|
-
const binary = binaryFileOf(entry);
|
|
606
|
-
if (binary === null || (binary === undefined && entry.text === undefined))
|
|
607
|
-
return null;
|
|
608
|
-
if (mode === 'credential' && entry.revision === undefined)
|
|
609
|
-
return null;
|
|
610
|
-
const head = headChange(entry);
|
|
611
|
-
if (head === null)
|
|
612
|
-
return null;
|
|
613
|
-
forgotten(answer, entry.path);
|
|
614
|
-
if (binary === undefined)
|
|
615
|
-
answer.documents.set(entry.path, entry.text);
|
|
616
|
-
else
|
|
617
|
-
answer.binaryFiles.set(entry.path, binary);
|
|
618
|
-
const revision = entry.revision ?? binary?.sha256;
|
|
619
|
-
if (revision !== undefined)
|
|
620
|
-
revised(answer, entry.path, revision);
|
|
621
|
-
if (head !== undefined)
|
|
622
|
-
answer.changes.set(entry.path, head);
|
|
623
|
-
}
|
|
624
|
-
}
|
|
625
|
-
const last = pending.at(-1);
|
|
626
|
-
const current = lines.get(tracked.authority);
|
|
627
|
-
if (current?.logEpoch === line.logEpoch) {
|
|
628
|
-
lines.set(tracked.authority, {
|
|
629
|
-
...current,
|
|
630
|
-
frames: current.frames.filter((frame) => frame.position > start),
|
|
631
|
-
held: current.held !== null && current.held > last.position ? current.held : last.position,
|
|
632
|
-
});
|
|
633
|
-
}
|
|
634
|
-
return {
|
|
635
|
-
page: {
|
|
636
|
-
kind: 'net-advancement',
|
|
637
|
-
roomVersion: roomVersion({ position: last.position.toString(), logEpoch: line.logEpoch }),
|
|
638
|
-
...(yield* answered(answer)),
|
|
639
|
-
},
|
|
640
|
-
schemas,
|
|
641
|
-
};
|
|
642
381
|
},
|
|
643
382
|
};
|
|
644
383
|
}
|