@agentshouse/mdruntime-adapter 0.1.0-cf41d9210cb6b → 0.1.0-cf863e7a50d6e

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/stream.js CHANGED
@@ -1,17 +1,31 @@
1
- import { ROW_WEIGHT, } from '@agentshouse/mdruntime';
2
- import { acceptedMessage, cursorPosition } from './actions.js';
3
- import { sha256Hex } from './digest.js';
1
+ import { ROW_WEIGHT, stepped, } from '@agentshouse/mdruntime';
2
+ import { acceptedMessage, cursorPosition, houseHistory } from './history.js';
3
+ import { streamedModels } from './model.js';
4
4
  import { answered, answering, binaryFileOf, folded, forgotten, headChange, revised, } from './read.js';
5
- import { roomVersion } from './version.js';
6
- const HELD_FRAMES_MAX = 256;
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,
@@ -21,89 +35,58 @@ function listedConversation(listed) {
21
35
  };
22
36
  }
23
37
  function position(value) {
24
- if (!/^(?:0|[1-9][0-9]*)$/.test(value))
38
+ if (!DECIMAL.test(value))
25
39
  return null;
26
40
  return BigInt(value);
27
41
  }
28
- function assembled(entries) {
29
- const whole = [];
30
- let open = null;
42
+ function* changed(tracked, entries, version, schemas) {
43
+ const answer = answering();
31
44
  for (const entry of entries) {
32
- if (entry.kind === 'piece') {
33
- if (open === null || open.entry.path !== entry.path || entry.text === undefined)
34
- return null;
35
- open.texts.push(entry.text);
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] };
45
+ yield ROW_WEIGHT + (entry.text?.length ?? 0);
46
+ if (entry.kind === 'folder') {
47
+ folded(answer, entry.path, entry.removed === true);
48
+ continue;
47
49
  }
48
- if (entry.continued === true)
50
+ if (entry.path === tracked.schema)
51
+ schemas.set(entry.path, entry);
52
+ forgotten(answer, entry.path);
53
+ if (entry.kind === 'removed') {
54
+ answer.removals.add(entry.path);
49
55
  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
56
  }
64
- return true;
65
- }
66
- catch {
67
- return false;
57
+ const binary = binaryFileOf(entry);
58
+ if (binary === undefined)
59
+ answer.documents.set(entry.path, entry.text ?? '');
60
+ else if (binary !== null)
61
+ answer.binaryFiles.set(entry.path, binary);
62
+ const revision = entry.revision ?? binary?.sha256;
63
+ if (revision !== undefined)
64
+ revised(answer, entry.path, revision);
65
+ const head = headChange(entry);
66
+ if (head)
67
+ answer.changes.set(entry.path, head);
68
68
  }
69
+ return { kind: 'net-advancement', roomVersion: version, ...(yield* answered(answer)) };
69
70
  }
70
- function resumed(kept, frame) {
71
- const last = frame.entries.at(-1);
72
- const point = { parts: frame.index + 1, from: frame.from, target: frame.target };
73
- if (last?.continued !== true)
74
- return { ...point, handled: frame.handled, piece: null };
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
- };
71
+ async function changePage(tracked, entries, version, mode) {
72
+ const schemas = new Map();
73
+ const page = await stepped(changed(tracked, entries, version, schemas));
74
+ const models = await streamedModels(schemas, tracked, mode);
75
+ return models === undefined ? page : { ...page, models };
90
76
  }
91
- export function houseNotifications(transport, mode) {
77
+ export function houseNotifications(transport, mode, discovering) {
92
78
  const stream = transport.stream;
93
- const lines = new Map();
94
- const kept = new Map();
95
- let receipts = null;
96
- let loaded = Promise.resolve();
97
- let acknowledging = null;
98
- let receiving = Promise.resolve();
99
- let verifying = 0;
100
- const locators = new Map();
79
+ const staged = new Map();
80
+ let socket = null;
81
+ const tracking = new Map();
101
82
  const observers = new Set();
102
83
  const conversationObservers = new Set();
103
84
  const modeObservers = new Set();
104
85
  let replicated = [];
86
+ let listedCursor = null;
105
87
  const live = new Set();
106
88
  let opening = null;
89
+ let announced = null;
107
90
  const runtime = crypto.randomUUID();
108
91
  function emit(event) {
109
92
  for (const observer of observers)
@@ -116,6 +99,7 @@ export function houseNotifications(transport, mode) {
116
99
  event.kind === 'commands' ||
117
100
  event.kind === 'options' ||
118
101
  event.kind === 'starting' ||
102
+ event.kind === 'subagents' ||
119
103
  event.kind === 'link' ||
120
104
  event.kind === 'deliveries') {
121
105
  live.add(event.conversation);
@@ -125,12 +109,31 @@ export function houseNotifications(transport, mode) {
125
109
  }
126
110
  function reopened(next) {
127
111
  opening = next;
128
- acknowledging = next;
112
+ announced = null;
113
+ socket = next;
114
+ staged.clear();
129
115
  const gapped = new Set([...replicated, ...live]);
130
116
  live.clear();
131
117
  for (const conversation of gapped)
132
118
  emitConversation({ kind: 'gap', conversation });
133
119
  emit({ kind: 'opened' });
120
+ if (mode === 'site')
121
+ announce(next, null);
122
+ }
123
+ function announce(via, frame) {
124
+ void discovering.opened(frame).then((discovery) => {
125
+ if (socket !== via)
126
+ return;
127
+ if (discovery === null) {
128
+ via.close();
129
+ return;
130
+ }
131
+ announced = { kind: 'discovered', discovery };
132
+ emit(announced);
133
+ }, () => {
134
+ if (socket === via)
135
+ via.close();
136
+ });
134
137
  }
135
138
  function converse(frame) {
136
139
  const conversation = frame.conversation_id;
@@ -149,6 +152,7 @@ export function houseNotifications(transport, mode) {
149
152
  return;
150
153
  emitConversation({ kind: 'commands', conversation, commands: [] });
151
154
  emitConversation({ kind: 'options', conversation, options: [] });
155
+ emitConversation({ kind: 'subagents', conversation, subagents: [] });
152
156
  return;
153
157
  }
154
158
  if (frame.type === 'commands') {
@@ -167,6 +171,14 @@ export function houseNotifications(transport, mode) {
167
171
  emitConversation({ kind: 'starting', conversation, step: frame.step });
168
172
  return;
169
173
  }
174
+ if (frame.type === 'subagents') {
175
+ emitConversation({
176
+ kind: 'subagents',
177
+ conversation,
178
+ subagents: structuredClone(frame.subagents),
179
+ });
180
+ return;
181
+ }
170
182
  if (frame.type === 'link') {
171
183
  emitConversation({ kind: 'link', conversation, connected: frame.connected });
172
184
  return;
@@ -188,171 +200,30 @@ export function houseNotifications(transport, mode) {
188
200
  return;
189
201
  emitConversation({ kind: 'accepted-message', conversation, message });
190
202
  }
191
- function announce(authority, at) {
192
- const version = roomVersion(at);
193
- for (const locator of locators.get(authority) ?? []) {
194
- emit({ kind: 'room-version', locator, roomVersion: version });
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);
203
+ function stage(frame, via) {
204
+ const held = staged.get(frame.carry);
205
+ if (frame.index !== (held?.parts ?? 0)) {
206
+ staged.delete(frame.carry);
224
207
  return;
225
208
  }
226
209
  if (held === undefined) {
227
- await forget([...kept.values()]
228
- .filter((other) => other.authority === frame.authority && other.fenced === null)
229
- .map((other) => other.carry));
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;
210
+ for (const [carry, other] of staged) {
211
+ if (other.authority === frame.authority)
212
+ staged.delete(carry);
213
+ }
248
214
  }
249
- kept.set(frame.carry, next);
215
+ const next = held ?? { authority: frame.authority, parts: 0, entries: [] };
216
+ next.entries.push(...frame.entries);
217
+ next.parts += 1;
218
+ staged.set(frame.carry, next);
250
219
  via?.received(frame.authority, frame.carry, frame.index);
251
220
  }
252
- async function keptEntries(carry, parts) {
253
- if (parts === 0)
254
- return [];
255
- if (receipts === null)
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);
221
+ function carried(frame) {
222
+ const held = staged.get(frame.carry);
223
+ staged.delete(frame.carry);
224
+ if ((held?.parts ?? 0) !== frame.parts)
273
225
  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
- };
226
+ publish(frame, held?.entries ?? []);
356
227
  }
357
228
  function handle(frame, via) {
358
229
  if (frame.type === 'signal') {
@@ -364,18 +235,31 @@ export function houseNotifications(transport, mode) {
364
235
  return;
365
236
  }
366
237
  if (frame.type === 'opening') {
238
+ if (via !== null && mode === 'credential')
239
+ announce(via, frame);
240
+ return;
241
+ }
242
+ if (frame.type === 'caught_up') {
367
243
  emit({
368
- kind: 'opening',
369
- expired: frame.expired.flatMap((authority) => locators.get(authority) ?? []),
244
+ kind: 'caught-up',
245
+ expired: frame.expired.flatMap((authority) => (tracking.get(authority) ?? []).map((tracked) => tracked.locator)),
370
246
  });
371
247
  return;
372
248
  }
373
249
  if (frame.type === 'authority_changed') {
374
- emit({ kind: 'authority-changed', scope: { authorities: frame.rooms } });
250
+ const change = discovering.changed(frame);
251
+ if (change !== null)
252
+ emit(change);
375
253
  return;
376
254
  }
377
255
  if (frame.type === 'conversations') {
378
- emitConversation({ kind: 'list', entries: frame.conversations.map(listedConversation) });
256
+ emitConversation({
257
+ kind: 'list',
258
+ entries: frame.conversations.map(listedConversation),
259
+ whole: frame.whole,
260
+ more: frame.more,
261
+ cursor: frame.cursor,
262
+ });
379
263
  return;
380
264
  }
381
265
  if (frame.type === 'conversation') {
@@ -391,6 +275,7 @@ export function houseNotifications(transport, mode) {
391
275
  frame.type === 'commands' ||
392
276
  frame.type === 'options' ||
393
277
  frame.type === 'starting' ||
278
+ frame.type === 'subagents' ||
394
279
  frame.type === 'link' ||
395
280
  frame.type === 'deliveries' ||
396
281
  frame.type === 'interactions' ||
@@ -399,59 +284,34 @@ export function houseNotifications(transport, mode) {
399
284
  return;
400
285
  }
401
286
  if (frame.type === 'part')
402
- return ahead(() => stage(frame, via));
403
- if (frame.type === 'carried')
404
- return ahead(() => carried(frame));
405
- }
406
- function ahead(work) {
407
- return receipts === null ? work() : receipts.ahead(work);
287
+ stage(frame, via);
288
+ else if (frame.type === 'carried')
289
+ carried(frame);
408
290
  }
409
291
  function publish(frame, entries) {
410
292
  const at = position(frame.position);
411
293
  const after = position(frame.after);
412
- if (at === null || after === null || after >= at) {
413
- interrupt(frame.authority);
294
+ if (at === null || after === null || after >= at)
414
295
  return;
415
- }
416
- const line = lines.get(frame.authority);
417
- if (line?.logEpoch === frame.log_epoch) {
418
- if (line.held !== null && at <= line.held)
419
- return;
420
- const last = line.frames.at(-1);
421
- if (last !== undefined && at <= last.position)
422
- return;
423
- const held = { after, position: at, entries };
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;
296
+ const from = roomVersion({ position: frame.after, logEpoch: frame.log_epoch });
297
+ const version = roomVersion({ position: frame.position, logEpoch: frame.log_epoch });
298
+ for (const tracked of tracking.get(frame.authority) ?? []) {
299
+ emit({
300
+ kind: 'room-change',
301
+ locator: tracked.locator,
302
+ from,
303
+ roomVersion: version,
304
+ read: () => changePage(tracked, entries, version, mode),
441
305
  });
442
- return;
443
306
  }
444
- verifying += 1;
445
- receiving = receiving
446
- .then(() => handle(frame, via))
447
- .finally(() => {
448
- verifying -= 1;
449
- });
450
- });
307
+ }
308
+ stream.observe((frame) => handle(frame, socket));
451
309
  stream.opened(reopened);
452
310
  stream.closed(({ revoked, lost }) => {
453
311
  opening = null;
454
- acknowledging = null;
312
+ announced = null;
313
+ socket = null;
314
+ staged.clear();
455
315
  emit({ kind: 'closed', revoked, lost });
456
316
  });
457
317
  return {
@@ -468,23 +328,30 @@ export function houseNotifications(transport, mode) {
468
328
  replicate(next) {
469
329
  replicated = [...next];
470
330
  },
331
+ hold(cursor) {
332
+ listedCursor = cursor;
333
+ },
471
334
  observe(notify) {
472
335
  conversationObservers.add(notify);
473
336
  return () => {
474
337
  conversationObservers.delete(notify);
475
338
  };
476
339
  },
340
+ ...(mode === 'credential'
341
+ ? {
342
+ agents: () => houseAgents(transport),
343
+ history: (request) => houseHistory(transport, request),
344
+ }
345
+ : {}),
477
346
  },
478
- observe(notify, port) {
347
+ observe(notify) {
479
348
  observers.add(notify);
480
- if (receipts === null) {
481
- receipts = port;
482
- loaded = load(port);
483
- }
484
- if (opening !== null) {
349
+ const replayed = opening === null ? [] : [{ kind: 'opened' }, announced];
350
+ if (replayed.length > 0) {
485
351
  queueMicrotask(() => {
486
- if (observers.has(notify))
487
- notify({ kind: 'opened' });
352
+ for (const event of replayed)
353
+ if (event !== null && observers.has(notify))
354
+ notify(event);
488
355
  });
489
356
  }
490
357
  return () => {
@@ -492,153 +359,19 @@ export function houseNotifications(transport, mode) {
492
359
  };
493
360
  },
494
361
  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
362
  opening = null;
504
- if (current === null)
505
- return;
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();
363
+ announced = null;
364
+ socket?.hold(rooms, runtime, listedCursor);
533
365
  },
534
366
  track(entries) {
535
- locators.clear();
367
+ tracking.clear();
536
368
  for (const entry of entries) {
537
- locators.set(entry.authority, [...(locators.get(entry.authority) ?? []), entry.locator]);
538
- if (lines.get(entry.authority)?.logEpoch !== entry.logEpoch) {
539
- lines.set(entry.authority, { logEpoch: entry.logEpoch, frames: [], held: null });
540
- }
369
+ tracking.set(entry.authority, [...(tracking.get(entry.authority) ?? []), entry]);
541
370
  }
542
- for (const authority of lines.keys()) {
543
- if (!locators.has(authority))
544
- lines.delete(authority);
371
+ for (const [carry, held] of staged) {
372
+ if (!tracking.has(held.authority))
373
+ staged.delete(carry);
545
374
  }
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
375
  },
643
376
  };
644
377
  }