@agentshouse/mdruntime-adapter 0.1.0-cbc5a1c3e1e08 → 0.1.0-cc097cb3b7109

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.
Files changed (62) hide show
  1. package/README.md +1 -1
  2. package/dist/actions.d.ts +6 -55
  3. package/dist/actions.d.ts.map +1 -1
  4. package/dist/actions.js +22 -274
  5. package/dist/adapter.d.ts.map +1 -1
  6. package/dist/adapter.js +159 -362
  7. package/dist/authored-path.d.ts +11 -0
  8. package/dist/authored-path.d.ts.map +1 -0
  9. package/dist/authored-path.js +35 -0
  10. package/dist/chunks.d.ts +38 -0
  11. package/dist/chunks.d.ts.map +1 -0
  12. package/dist/chunks.js +247 -0
  13. package/dist/discovery.d.ts +21 -10
  14. package/dist/discovery.d.ts.map +1 -1
  15. package/dist/discovery.js +69 -35
  16. package/dist/history.d.ts +12 -0
  17. package/dist/history.d.ts.map +1 -0
  18. package/dist/history.js +92 -0
  19. package/dist/house-model.d.ts +697 -1
  20. package/dist/house-model.d.ts.map +1 -1
  21. package/dist/house-model.js +405 -484
  22. package/dist/index.d.ts +9 -4
  23. package/dist/index.d.ts.map +1 -1
  24. package/dist/index.js +8 -3
  25. package/dist/model.d.ts +5 -8
  26. package/dist/model.d.ts.map +1 -1
  27. package/dist/model.js +29 -34
  28. package/dist/read.d.ts +21 -59
  29. package/dist/read.d.ts.map +1 -1
  30. package/dist/read.js +50 -330
  31. package/dist/refusal.d.ts +1 -3
  32. package/dist/refusal.d.ts.map +1 -1
  33. package/dist/refusal.js +5 -6
  34. package/dist/room-types.d.ts +1 -3
  35. package/dist/room-types.d.ts.map +1 -1
  36. package/dist/room-types.js +8 -12
  37. package/dist/search.d.ts +5 -0
  38. package/dist/search.d.ts.map +1 -0
  39. package/dist/search.js +47 -0
  40. package/dist/site.d.ts.map +1 -1
  41. package/dist/site.js +76 -167
  42. package/dist/space-schema.d.ts +7 -0
  43. package/dist/space-schema.d.ts.map +1 -0
  44. package/dist/space-schema.js +18 -0
  45. package/dist/stream.d.ts +16 -15
  46. package/dist/stream.d.ts.map +1 -1
  47. package/dist/stream.js +237 -423
  48. package/dist/transport.d.ts +47 -38
  49. package/dist/transport.d.ts.map +1 -1
  50. package/dist/transport.js +54 -11
  51. package/dist/upload.d.ts.map +1 -1
  52. package/dist/upload.js +2 -2
  53. package/dist/write.d.ts +6 -2
  54. package/dist/write.d.ts.map +1 -1
  55. package/dist/write.js +21 -30
  56. package/package.json +2 -2
  57. package/dist/gather.d.ts +0 -4
  58. package/dist/gather.d.ts.map +0 -1
  59. package/dist/gather.js +0 -35
  60. package/dist/part.d.ts +0 -15
  61. package/dist/part.d.ts.map +0 -1
  62. package/dist/part.js +0 -82
package/dist/adapter.js CHANGED
@@ -1,210 +1,124 @@
1
1
  import { stepped } from '@agentshouse/mdruntime';
2
- import { DISCOVER_PREFIXES, capabilities, discoveredRoom, mapDiscovery, parseDiscovery, trackedFrom, } from './discovery.js';
3
- import { manifestedModels, partModels, streamedModels, viewModels } from './model.js';
4
- import { gathered, gatheredEach, selections } from './gather.js';
2
+ import { capabilities, discoveredRoom, mapDiscovery, parseAuthorityChange, parseDiscovery, trackedFrom, } from './discovery.js';
5
3
  import { createSiteAdapter } from './site.js';
6
- import { authorityRoot, bootstrapping, emptyScope, housePart, manifested, parseEnumeration, parseFileAddress, parseGrant, parseParted, partInventory, refreshFrom, viewOf, wholeView, } from './read.js';
7
- import { PART_ATTEMPTS, partArrival, partFrame, unverifiedPart } from './part.js';
8
- import { sha256Hex } from './digest.js';
4
+ import { parseFileAddress, parseGrant } from './read.js';
5
+ import { chunkedHead, chunkLister, chunkPart } from './chunks.js';
6
+ import { spaceSchemas } from './space-schema.js';
9
7
  import { finishedUpload, houseUpload } from './upload.js';
10
- import { houseAction } from './actions.js';
11
- import { classifyDoor, classifyRead, discoveryFailure, doorRefusal } from './refusal.js';
12
- import { houseNotifications } from './stream.js';
13
- import { DOOR_BATCH, DOOR_BATCH_UPLOAD, DOOR_BOOTSTRAP, DOOR_DISCOVER, DOOR_ENUMERATE, DOOR_FILES_GET, DOOR_REVISIONS, } from './transport.js';
8
+ import { houseAction, HOUSE_LEADING_READS, HOUSE_UNKEPT_READS } from './actions.js';
9
+ import { houseSearch } from './search.js';
10
+ import { classifyDoor, doorRefusal } from './refusal.js';
11
+ import { houseNotifications, } from './stream.js';
12
+ import { houseDoorRoute, } from './transport.js';
14
13
  import { batchPaths, deltaBody, deltaBytes, deltaDigest, historyOutcome, houseChanges, houseMove, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable, } from './write.js';
14
+ import { admittedPath } from './authored-path.js';
15
+ import { HOUSE_TYPED_PATHS } from './house-model.js';
15
16
  import { HOUSE_NAMEABLE_ROOM_TYPES, HOUSE_ROOM_TYPES } from './room-types.js';
16
- import { followsVersion, logPosition, presented, reachedVersion, roomVersion, } from './version.js';
17
+ import { followsVersion, reachedVersion, roomVersion } from './version.js';
17
18
  const UNCERTAIN = { kind: 'transport-uncertainty' };
18
19
  const UNCERTAIN_READ = { kind: 'transport-uncertainty' };
20
+ const OCTET_STREAM = 'application/octet-stream';
19
21
  const EXPIRED_ADDRESS = 403;
20
22
  function lapsedGrant(outcome) {
21
23
  return outcome.kind === 'rejected' && outcome.code === 'upload_unavailable';
22
24
  }
23
- async function heldFiles(authority, held, bound) {
24
- const listed = await held.files(null, bound + 1);
25
- const files = listed.slice(0, bound);
26
- const through = listed.length > bound ? (files.at(-1)?.path ?? null) : null;
27
- return files.length === 0 ? null : { room: authority, through, files };
28
- }
29
- async function reused(scope, held) {
30
- const sent = new Set(scope.contents.map((entry) => entry.path));
31
- const contents = [...scope.contents];
32
- const asked = scope.files.filter((file) => file.binary === undefined && !sent.has(file.path));
33
- if (asked.length === 0)
34
- return scope;
35
- if (held === undefined)
36
- return null;
37
- const kept = await held.contents(asked.map(({ path }) => path));
38
- for (const file of asked) {
39
- const found = kept.get(file.path);
40
- if (found === undefined ||
41
- found.revision !== file.revision ||
42
- (await sha256Hex(found.content)) !== file.sha256) {
43
- return null;
44
- }
45
- contents.push({ path: file.path, content: found.content });
46
- }
47
- return { ...scope, contents };
48
- }
49
25
  export function createAgentsHouseAdapter(options) {
50
26
  if ('site' in options)
51
27
  return createSiteAdapter(options.site, options.snapshot === true);
52
28
  const transport = options.transport;
53
- const notifications = houseNotifications(transport, 'credential');
29
+ const spaces = spaceSchemas();
30
+ const notifications = houseNotifications(transport, 'credential', {
31
+ opened: async (frame) => (frame === null ? null : opened(frame)),
32
+ changed,
33
+ expired: (authorities) => lister.askAll(authorities.flatMap((authority) => [...tracked.values()].filter((entry) => entry.authority === authority))),
34
+ }, spaces);
54
35
  const tracked = new Map();
55
- const handed = new Map();
56
- let heldRevisions;
36
+ const lister = chunkLister(transport, () => declared().max_prefixes);
37
+ const chunked = new Map();
38
+ const renewals = new WeakMap();
57
39
  let bounds;
58
40
  function declared() {
59
41
  if (bounds === undefined)
60
42
  throw new Error('no Discovery declared the bounds');
61
43
  return bounds;
62
44
  }
63
- async function fetchedPart(entry, continued, listed, received, arriving) {
64
- if (received !== undefined) {
65
- const kept = new Uint8Array(received);
66
- const held = await housePart(continued.room, kept, listed, 'credential');
67
- if (held !== null)
68
- return 'kind' in held ? held : { scope: held, frame: kept };
69
- }
70
- for (let attempt = 0; attempt < PART_ATTEMPTS; attempt += 1) {
71
- const answered = await transport.door(DOOR_BOOTSTRAP, {
72
- prefixes: [authorityRoot(entry.handle)],
73
- part: listed.part,
74
- ...(continued.held === undefined ? {} : { held: [continued.held] }),
75
- }, partArrival(listed, arriving));
76
- const failure = classifyRead(answered.status, answered.body, entry.locator);
77
- if (failure !== null)
78
- return failure;
79
- const frame = partFrame(answered.body);
80
- if (frame === null)
81
- continue;
82
- const scope = await housePart(continued.room, frame, listed, 'credential');
83
- if (scope !== null)
84
- return 'kind' in scope ? scope : { scope, frame };
85
- }
86
- return unverifiedPart(entry.locator);
87
- }
88
- async function manifestPage(asked, continued) {
89
- const inventory = partInventory(continued.room);
90
- if (inventory.parts === 0) {
91
- const page = await partPage(asked, continued, undefined, undefined);
92
- return page.kind === 'bootstrap' ? { ...page, inventory } : page;
93
- }
94
- const { models, seen } = await manifestedModels(continued.room, asked.entry);
95
- return manifested(continued.room, inventory, JSON.stringify({ ...continued, seen }), models);
96
- }
97
- async function partPage(asked, continued, received, arriving) {
98
- const { entry } = asked;
99
- const listed = continued.room.parts[continued.next];
100
- const sent = listed === undefined
101
- ? { scope: emptyScope(continued.room), frame: null }
102
- : await fetchedPart(entry, continued, listed, received, arriving);
103
- if ('kind' in sent)
104
- return sent;
105
- const scope = await reused(sent.scope, asked.held);
106
- if (scope === null) {
107
- return asked.held === undefined
108
- ? UNCERTAIN_READ
109
- : bootstrapTogether({ entry, held: undefined });
110
- }
111
- const next = continued.next + 1;
112
- const more = next < continued.room.parts.length;
113
- if (continued.next === 0 && !more)
114
- handed.set(entry.locator, roomVersion(scope));
115
- else
116
- handed.delete(entry.locator);
117
- notifications.reach(entry.authority, scope);
118
- const seen = [
119
- ...continued.seen,
120
- ...(scope.files.some((file) => file.path === entry.schema) ? [entry.schema] : []),
121
- ];
122
- const models = await partModels(scope, entry, new Set(seen), !more);
45
+ function opened(frame) {
46
+ const document = parseDiscovery(frame);
47
+ if (document === null)
48
+ return null;
49
+ bounds = document.bounds;
50
+ tracked.clear();
51
+ lister.forget();
52
+ for (const entry of trackedFrom(document))
53
+ tracked.set(entry.locator, entry);
54
+ notifications.track([...tracked.values()]);
123
55
  return {
124
- ...(await stepped(bootstrapping(scope))),
125
- ...(models === undefined ? {} : { models }),
126
- ...(more ? { pageToken: JSON.stringify({ ...continued, next, seen }) } : {}),
127
- ...(sent.frame === null ? {} : { received: sent.frame }),
56
+ ...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document.actions)),
57
+ member: document.member,
128
58
  };
129
59
  }
130
- async function enumeratedPage(ask, page) {
131
- const answer = await transport.door(DOOR_ENUMERATE, {
132
- prefixes: [authorityRoot(ask.entry.handle)],
133
- positions: [
134
- {
135
- ...presented(ask.entry.authority, { position: page.after, logEpoch: ask.from.logEpoch }),
136
- page: { through: page.through, read: page.read },
137
- },
138
- ],
139
- });
140
- const failure = classifyRead(answer.status, answer.body, ask.entry.locator);
141
- if (failure !== null)
142
- return failure;
143
- const enumeration = parseEnumeration(answer.body, 'credential');
144
- if (enumeration === null)
145
- return UNCERTAIN_READ;
146
- return (viewOf(enumeration, ask.entry) ?? { kind: 'room-not-readable', locator: ask.entry.locator });
60
+ function changed(frame) {
61
+ const change = parseAuthorityChange(frame);
62
+ if (change === null)
63
+ return null;
64
+ for (const locator of change.left)
65
+ tracked.delete(locator);
66
+ for (const entry of trackedFrom(change))
67
+ tracked.set(entry.locator, entry);
68
+ notifications.track([...tracked.values()]);
69
+ return {
70
+ kind: 'authority-changed',
71
+ rooms: change.authorities.map((authority) => discoveredRoom(authority)),
72
+ left: change.left,
73
+ member: change.member,
74
+ };
147
75
  }
148
- async function enumeratedRoom(enumeration, ask) {
149
- const first = viewOf(enumeration, ask.entry);
150
- if (first === undefined)
151
- return { kind: 'room-not-readable', locator: ask.entry.locator };
152
- const view = await wholeView(first, (page) => enumeratedPage(ask, page));
153
- if ('kind' in view)
154
- return view;
155
- notifications.reach(ask.entry.authority, view);
156
- const answer = await refreshFrom(view, ask.fromRoomVersion);
157
- if (answer.kind !== 'net-advancement')
158
- return answer;
159
- handed.set(ask.entry.locator, roomVersion(view));
160
- const models = await viewModels(view, ask.entry);
161
- return models === undefined ? answer : { ...answer, models };
76
+ async function listedRoom(entry) {
77
+ const listed = await lister.list(entry);
78
+ if ('kind' in listed)
79
+ return listed;
80
+ const head = await chunkedHead(listed, entry, spaces);
81
+ if (head.kind === 'bootstrap')
82
+ chunked.set(entry.locator, listed);
83
+ return head;
162
84
  }
163
- async function streamed(entry, request, from) {
164
- if (handed.get(entry.locator) !== request.fromRoomVersion)
85
+ async function chunkRead(entry, id) {
86
+ const room = chunked.get(entry.locator);
87
+ const address = room?.chunks.get(id);
88
+ if (room === undefined || address === undefined)
165
89
  return null;
166
- const asked = notifications.edited(entry, from);
167
- const kept = asked.length === 0 || heldRevisions === undefined
168
- ? new Map()
169
- : await heldRevisions(entry.locator, asked);
170
- const advanced = await stepped(notifications.advance(entry, from, (path, revision) => kept.get(path) === revision));
171
- if (advanced === null)
90
+ const read = await transport.download(address.url);
91
+ if (read.status !== EXPIRED_ADDRESS)
92
+ return { room, read };
93
+ const renewed = await renewal(entry, room);
94
+ if ('kind' in renewed || !renewed.chunks.has(id))
172
95
  return null;
173
- handed.set(entry.locator, advanced.page.roomVersion);
174
- const models = await streamedModels(advanced.schemas, entry, 'credential');
175
- return models === undefined ? advanced.page : { ...advanced.page, models };
96
+ chunked.set(entry.locator, renewed);
97
+ return { room: renewed, read: await transport.download(renewed.chunks.get(id).url) };
176
98
  }
177
- function held(rooms) {
178
- const kept = rooms.flatMap((room) => {
179
- const entry = tracked.get(room.locator);
180
- const at = logPosition(room.roomVersion);
181
- if (entry === undefined || at === null)
182
- return [];
183
- handed.set(room.locator, room.roomVersion);
184
- notifications.reach(entry.authority, at);
185
- return [presented(entry.authority, at)];
186
- });
187
- notifications.send(kept);
99
+ function renewal(entry, stale) {
100
+ const held = renewals.get(stale);
101
+ if (held !== undefined)
102
+ return held;
103
+ const renewed = lister.renew(entry, [...chunked.keys()].flatMap((locator) => tracked.get(locator) ?? []));
104
+ renewals.set(stale, renewed);
105
+ return renewed;
188
106
  }
189
- async function adoptedMove(entry, into, outcome) {
190
- if (outcome.kind === 'accepted' && outcome.destination !== undefined) {
191
- await adopted(into, { kind: 'accepted', ...outcome.destination });
107
+ function hold(rooms) {
108
+ for (const room of rooms) {
109
+ const listed = chunked.get(room.locator);
110
+ if (listed !== undefined &&
111
+ room.roomVersion !== null &&
112
+ reachedVersion(room.roomVersion, roomVersion(listed), listed.logEpoch))
113
+ chunked.delete(room.locator);
192
114
  }
193
- return adopted(entry, outcome);
115
+ notifications.send(rooms);
194
116
  }
195
- async function adopted(entry, outcome) {
196
- if (outcome.kind !== 'accepted')
197
- return outcome;
198
- const held = handed.get(entry.locator);
199
- if (held === undefined)
200
- return outcome;
201
- const follows = followsVersion(held, outcome.roomVersion);
202
- if (follows)
203
- handed.set(entry.locator, outcome.roomVersion);
204
- const at = logPosition(outcome.roomVersion);
205
- if (follows && at !== null)
206
- notifications.reach(entry.authority, at);
207
- return outcome;
117
+ async function chunkPage(entry, id, arriving) {
118
+ const fetched = await chunkRead(entry, id);
119
+ if (fetched === null || fetched.read.status !== 200)
120
+ return UNCERTAIN_READ;
121
+ return chunkPart(fetched.read.body, fetched.room, id, arriving);
208
122
  }
209
123
  function authorityFor(locator) {
210
124
  return tracked.get(locator);
@@ -223,116 +137,18 @@ export function createAgentsHouseAdapter(options) {
223
137
  return result;
224
138
  return { ...result, at: { locator, roomVersion: roomVersion({ position, logEpoch }) } };
225
139
  }
226
- async function holding(asks) {
227
- const bound = Math.floor(declared().max_held_files / Math.max(1, asks.filter((ask) => ask.held !== undefined).length));
228
- const held = [];
229
- for (const ask of asks) {
230
- if (ask.held === undefined || bound === 0)
231
- continue;
232
- const files = await heldFiles(ask.entry.authority, ask.held, bound);
233
- if (files !== null)
234
- held.push(files);
235
- }
236
- return held;
237
- }
238
- async function bootstrapped(asks, answer) {
239
- let open = asks.map((asked, ask) => ({ entry: asked.entry, asked, ask }));
240
- while (open.length > 0) {
241
- const unreached = [];
242
- for (const part of selections(open, declared().max_prefixes)) {
243
- const held = await holding(part.map(({ asked }) => asked));
244
- const answered = await transport.door(DOOR_BOOTSTRAP, {
245
- prefixes: part.map(({ entry }) => authorityRoot(entry.handle)),
246
- ...(held.length === 0 ? {} : { held }),
247
- });
248
- const classified = part.map(({ entry }) => classifyDoor(answered.status, answered.body, entry.locator));
249
- const parted = classified[0] === null ? parseParted(answered.body) : null;
250
- for (const [index, asked] of part.entries()) {
251
- const failure = classified[index];
252
- if (failure !== null && failure !== undefined) {
253
- answer(asked.ask, failure);
254
- continue;
255
- }
256
- if (parted === null) {
257
- answer(asked.ask, UNCERTAIN_READ);
258
- continue;
259
- }
260
- const room = parted.rooms.find((candidate) => candidate.anchor === asked.entry.authority);
261
- if (room === undefined && parted.next !== undefined) {
262
- unreached.push(asked);
263
- continue;
264
- }
265
- if (room === undefined) {
266
- answer(asked.ask, { kind: 'room-not-readable', locator: asked.entry.locator });
267
- continue;
268
- }
269
- const kept = held.find((files) => files.room === asked.entry.authority);
270
- answer(asked.ask, await manifestPage(asked.asked, {
271
- room,
272
- next: 0,
273
- seen: [],
274
- ...(kept === undefined ? {} : { held: kept }),
275
- }));
276
- }
277
- }
278
- open = unreached;
279
- }
280
- }
281
- function layered(asks) {
282
- const depths = new Map();
283
- const layers = [];
284
- for (const ask of asks) {
285
- const depth = depths.get(ask.ask.entry.authority) ?? 0;
286
- depths.set(ask.ask.entry.authority, depth + 1);
287
- (layers[depth] ??= []).push(ask);
288
- }
289
- return layers;
290
- }
291
- async function enumerated(asks) {
292
- const answers = [];
293
- const parts = layered(asks.map((ask, index) => ({ ask, index }))).flatMap((layer) => selections(layer, declared().max_prefixes));
294
- for (const part of parts) {
295
- let open = [...part];
296
- while (open.length > 0) {
297
- const answer = await transport.door(DOOR_ENUMERATE, {
298
- prefixes: open.map(({ ask }) => authorityRoot(ask.entry.handle)),
299
- positions: open.map(({ ask }) => presented(ask.entry.authority, ask.from)),
300
- });
301
- const classified = open.map(({ ask }) => classifyRead(answer.status, answer.body, ask.entry.locator));
302
- if (classified[0]?.kind === 'beyond-horizon') {
303
- const named = doorRefusal(answer.body)?.fields.authority;
304
- const expired = open.filter(({ ask }) => ask.entry.authority === named);
305
- const answered = expired.length === 0 ? UNCERTAIN_READ : { kind: 'beyond-horizon' };
306
- const gone = expired.length === 0 ? open : expired;
307
- for (const ask of gone)
308
- answers[ask.index] = answered;
309
- open = open.filter((ask) => !gone.includes(ask));
310
- continue;
311
- }
312
- const enumeration = classified[0] === null ? parseEnumeration(answer.body, 'credential') : null;
313
- for (const [answerIndex, { ask, index }] of open.entries()) {
314
- const failure = classified[answerIndex];
315
- if (failure !== null && failure !== undefined) {
316
- answers[index] = failure;
317
- continue;
318
- }
319
- answers[index] =
320
- enumeration === null ? UNCERTAIN_READ : await enumeratedRoom(enumeration, ask);
321
- }
322
- open = [];
323
- }
324
- }
325
- return answers;
326
- }
327
- const bootstrapTogether = gatheredEach(bootstrapped);
328
- const enumerateTogether = gathered(enumerated);
329
140
  async function uploaded(head, changes, delta, bytes, entry, handed, keep) {
330
141
  const paths = batchPaths(changes);
331
142
  const sha256 = await deltaDigest(delta);
332
143
  if (handed !== undefined && handed.sha256 === sha256) {
333
144
  return { body: { ...head, paths, upload: handed, runtime: notifications.runtime } };
334
145
  }
335
- const minted = await transport.door(DOOR_BATCH_UPLOAD, { ...head, paths, bytes, sha256 });
146
+ const minted = await transport.door(houseDoorRoute('files/batch-upload'), {
147
+ ...head,
148
+ paths,
149
+ bytes,
150
+ sha256,
151
+ });
336
152
  if (minted.status !== 200) {
337
153
  return {
338
154
  outcome: await stepped(mutationOutcome(minted.status, minted.body, entry.locator, entry.handle)),
@@ -342,7 +158,6 @@ export function createAgentsHouseAdapter(options) {
342
158
  if (grant === null)
343
159
  return { outcome: UNCERTAIN };
344
160
  const delivered = await transport.transfer({
345
- act: 'authored_batch_upload',
346
161
  url: grant.url,
347
162
  body: `${grant.operation}\n${delta}`,
348
163
  });
@@ -380,11 +195,13 @@ export function createAgentsHouseAdapter(options) {
380
195
  : { body: inline };
381
196
  if ('outcome' in prepared)
382
197
  return prepared.outcome;
383
- const answer = await transport.door(DOOR_BATCH, prepared.body);
198
+ const answer = await transport.door(houseDoorRoute('files/batch'), prepared.body);
384
199
  const stagedFiles = await staged(answer, request);
385
200
  if (stagedFiles === false)
386
201
  return UNCERTAIN;
387
- const settled = stagedFiles === null ? answer : await transport.door(DOOR_BATCH, prepared.body);
202
+ const settled = stagedFiles === null
203
+ ? answer
204
+ : await transport.door(houseDoorRoute('files/batch'), prepared.body);
388
205
  if (stagedFiles === true && (await staged(settled, request)) !== null)
389
206
  return UNCERTAIN;
390
207
  return stepped(mutationOutcome(settled.status, settled.body, entry.locator, entry.handle, into === undefined
@@ -412,9 +229,22 @@ export function createAgentsHouseAdapter(options) {
412
229
  function linked(answer, locator) {
413
230
  const address = addressed(answer, locator);
414
231
  return address.kind === 'address'
415
- ? { kind: 'link', url: address.url, name: address.name }
232
+ ? { kind: 'link', url: address.url, name: address.name, mediaType: address.mediaType }
416
233
  : address;
417
234
  }
235
+ function refusedAttach(answer, locator) {
236
+ const failure = classifyDoor(answer.status, answer.body, locator);
237
+ if (failure === null)
238
+ return null;
239
+ return failure.kind === 'scoped-refusal'
240
+ ? {
241
+ kind: 'rejected',
242
+ code: failure.code,
243
+ fields: failure.fields,
244
+ retryable: failure.retryable,
245
+ }
246
+ : failure;
247
+ }
418
248
  async function downloaded(ask, locator) {
419
249
  let address = addressed(await ask(), locator);
420
250
  if (address.kind !== 'address')
@@ -439,7 +269,7 @@ export function createAgentsHouseAdapter(options) {
439
269
  const entry = authorityFor(request.locator);
440
270
  if (entry === undefined)
441
271
  return null;
442
- return () => transport.door(DOOR_FILES_GET, {
272
+ return () => transport.door(houseDoorRoute('files/read'), {
443
273
  room_ref: entry.authority,
444
274
  path: request.path,
445
275
  revision: request.revision,
@@ -448,72 +278,20 @@ export function createAgentsHouseAdapter(options) {
448
278
  return {
449
279
  roomTypes: HOUSE_ROOM_TYPES,
450
280
  nameableRoomTypes: HOUSE_NAMEABLE_ROOM_TYPES,
281
+ typedPaths: HOUSE_TYPED_PATHS,
282
+ pathRule: admittedPath,
283
+ unkeptReads: HOUSE_UNKEPT_READS,
284
+ leadingReads: HOUSE_LEADING_READS,
451
285
  async authorize() {
452
286
  return options.authorize();
453
287
  },
454
- async discover(_authorization, scope) {
455
- const answer = await transport.door(DOOR_DISCOVER, {
456
- prefixes: [...DISCOVER_PREFIXES],
457
- ...(scope === undefined ? {} : { rooms: scope.authorities }),
458
- });
459
- const failed = discoveryFailure(answer.status, answer.body);
460
- if (failed !== null)
461
- return failed;
462
- const document = parseDiscovery(answer.body);
463
- if (document === null)
464
- return { kind: 'transport-uncertainty' };
465
- bounds = document.bounds;
466
- const entries = trackedFrom(document);
467
- const covered = scope === undefined
468
- ? null
469
- : [
470
- ...new Set([
471
- ...[...tracked.values()]
472
- .filter((entry) => scope.authorities.includes(entry.authority))
473
- .map((entry) => entry.locator),
474
- ...entries.map((entry) => entry.locator),
475
- ]),
476
- ];
477
- if (covered === null)
478
- tracked.clear();
479
- else
480
- for (const locator of covered)
481
- tracked.delete(locator);
482
- for (const entry of entries)
483
- tracked.set(entry.locator, entry);
484
- for (const locator of handed.keys())
485
- if (!tracked.has(locator))
486
- handed.delete(locator);
487
- notifications.track([...tracked.values()]);
488
- return {
489
- ...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document.actions, [...tracked.values()])),
490
- member: document.member,
491
- ...(covered === null ? {} : { covered }),
492
- };
493
- },
494
288
  async bootstrap(_authorization, request) {
495
289
  const entry = authorityFor(request.locator);
496
290
  if (entry === undefined)
497
291
  return { kind: 'room-not-readable', locator: request.locator };
498
- const asked = { entry, held: request.held };
499
- if (request.pageToken !== undefined) {
500
- return partPage(asked, JSON.parse(request.pageToken), request.received, request.arriving);
501
- }
502
- return bootstrapTogether(asked);
503
- },
504
- async refresh(_authorization, request) {
505
- const entry = authorityFor(request.locator);
506
- if (entry === undefined)
507
- return { kind: 'room-not-readable', locator: request.locator };
508
- if (request.pageToken !== undefined)
509
- return { kind: 'transport-uncertainty' };
510
- const from = logPosition(request.fromRoomVersion);
511
- if (from === null)
512
- return { kind: 'beyond-horizon' };
513
- const answered = await streamed(entry, request, from);
514
- if (answered !== null)
515
- return answered;
516
- return enumerateTogether({ entry, from, fromRoomVersion: request.fromRoomVersion });
292
+ return request.pageToken === undefined
293
+ ? listedRoom(entry)
294
+ : chunkPage(entry, request.pageToken, request.arriving);
517
295
  },
518
296
  async mutate(_authorization, request, keep) {
519
297
  const entry = authorityFor(request.locator);
@@ -530,31 +308,27 @@ export function createAgentsHouseAdapter(options) {
530
308
  : houseMove(batch, entry.handle, into.handle);
531
309
  if (mapped.kind === 'unmapped')
532
310
  return rejectedMapping(mapped);
533
- const head = operationHead(batch);
311
+ const head = operationHead(batch, entry.authority);
534
312
  const delta = deltaBody(mapped.changes);
535
313
  const bytes = deltaBytes(delta);
536
314
  const handed = request.upload;
537
315
  const answer = (upload) => submit(request, head, mapped.changes, delta, bytes, entry, upload, keep, into);
538
- const settle = (outcome) => into === undefined ? adopted(entry, outcome) : adoptedMove(entry, into, outcome);
539
316
  const outcome = await answer(handed);
540
317
  if (handed === undefined || !lapsedGrant(outcome))
541
- return settle(outcome);
542
- return settle(await answer(undefined));
318
+ return outcome;
319
+ return answer(undefined);
543
320
  },
544
321
  async history(_authorization, request) {
545
322
  const entry = authorityFor(request.locator);
546
323
  if (entry === undefined)
547
324
  return { kind: 'room-not-readable', locator: request.locator };
548
- const answer = await transport.door(DOOR_REVISIONS, revisionBody({
325
+ const answer = await transport.door(houseDoorRoute('files/revisions/list'), revisionBody({
549
326
  path: request.path,
550
327
  handle: entry.handle,
551
328
  ...(request.revision === undefined ? {} : { revision: request.revision }),
552
329
  ...(request.pageToken === undefined ? {} : { pageToken: request.pageToken }),
553
330
  }));
554
- return historyOutcome(answer.status, answer.body, entry.locator, {
555
- path: request.path,
556
- ...(request.revision === undefined ? {} : { revision: request.revision }),
557
- });
331
+ return historyOutcome(answer.status, answer.body, entry.locator, request);
558
332
  },
559
333
  async binary(_authorization, request) {
560
334
  const ask = pathAddress(request);
@@ -568,6 +342,35 @@ export function createAgentsHouseAdapter(options) {
568
342
  return { kind: 'room-not-readable', locator: request.locator };
569
343
  return linked(await ask(), request.locator);
570
344
  },
345
+ async attach(_authorization, request) {
346
+ const entry = authorityFor(request.locator);
347
+ if (entry === undefined)
348
+ return { kind: 'room-not-readable', locator: request.locator };
349
+ const declared = await transport.door(houseDoorRoute('files/attach'), {
350
+ room_ref: entry.authority,
351
+ name: request.name,
352
+ bytes: request.byteLength,
353
+ sha256: request.sha256,
354
+ media_type: request.mediaType.length > 0 ? request.mediaType : OCTET_STREAM,
355
+ });
356
+ const refused = refusedAttach(declared, request.locator);
357
+ if (refused !== null)
358
+ return refused;
359
+ const upload = houseUpload(declared.body?.upload);
360
+ if (upload === null)
361
+ return UNCERTAIN_READ;
362
+ const finished = await finishedUpload(transport, upload, request.blob);
363
+ if (finished === null)
364
+ return UNCERTAIN_READ;
365
+ const unfinished = refusedAttach(finished, request.locator);
366
+ if (unfinished !== null)
367
+ return unfinished;
368
+ const { path, revision } = (finished.body ?? {});
369
+ const root = `/rooms/${entry.handle}/`;
370
+ return typeof path === 'string' && path.startsWith(root) && typeof revision === 'string'
371
+ ? { kind: 'attached', path: path.slice(root.length), revision }
372
+ : UNCERTAIN_READ;
373
+ },
571
374
  reached(locator, version, target) {
572
375
  return reachedVersion(version, target, authorityFor(locator)?.logEpoch);
573
376
  },
@@ -577,18 +380,12 @@ export function createAgentsHouseAdapter(options) {
577
380
  async action(_authorization, request) {
578
381
  return withAt(await houseAction(transport, request));
579
382
  },
383
+ search(_authorization, request) {
384
+ return houseSearch(transport, [...tracked.values()], request);
385
+ },
580
386
  roomStream: {
581
- hold: held,
582
- reopen: notifications.reopen,
583
- observe(notify, receipts, revisions) {
584
- heldRevisions = revisions;
585
- return notifications.observe(notify, receipts);
586
- },
587
- published(locator, roomVersion) {
588
- const at = logPosition(roomVersion);
589
- if (at !== null)
590
- notifications.published(locator, at);
591
- },
387
+ hold,
388
+ observe: notifications.observe,
592
389
  },
593
390
  conversations: notifications.conversations,
594
391
  serviceMode: notifications.serviceMode,