@agentshouse/mdruntime-adapter 0.1.0-cc1bdabaf4e28 → 0.1.0-cc1d67536ab19
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/README.md +1 -1
- package/dist/actions.d.ts +6 -59
- package/dist/actions.d.ts.map +1 -1
- package/dist/actions.js +22 -292
- package/dist/adapter.d.ts.map +1 -1
- package/dist/adapter.js +159 -362
- package/dist/authored-path.d.ts +11 -0
- package/dist/authored-path.d.ts.map +1 -0
- package/dist/authored-path.js +35 -0
- package/dist/chunks.d.ts +38 -0
- package/dist/chunks.d.ts.map +1 -0
- package/dist/chunks.js +247 -0
- package/dist/discovery.d.ts +21 -10
- package/dist/discovery.d.ts.map +1 -1
- package/dist/discovery.js +69 -35
- 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 +697 -1
- package/dist/house-model.d.ts.map +1 -1
- package/dist/house-model.js +405 -442
- package/dist/index.d.ts +9 -4
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +8 -3
- package/dist/model.d.ts +5 -8
- package/dist/model.d.ts.map +1 -1
- package/dist/model.js +29 -34
- package/dist/read.d.ts +21 -59
- package/dist/read.d.ts.map +1 -1
- package/dist/read.js +50 -330
- package/dist/refusal.d.ts +1 -3
- package/dist/refusal.d.ts.map +1 -1
- package/dist/refusal.js +5 -6
- package/dist/room-types.d.ts +1 -3
- package/dist/room-types.d.ts.map +1 -1
- package/dist/room-types.js +8 -12
- 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 +75 -166
- package/dist/space-schema.d.ts +7 -0
- package/dist/space-schema.d.ts.map +1 -0
- package/dist/space-schema.js +18 -0
- package/dist/stream.d.ts +16 -15
- package/dist/stream.d.ts.map +1 -1
- package/dist/stream.js +237 -423
- package/dist/transport.d.ts +47 -38
- package/dist/transport.d.ts.map +1 -1
- package/dist/transport.js +54 -11
- package/dist/upload.d.ts.map +1 -1
- package/dist/upload.js +2 -2
- package/dist/write.d.ts +6 -2
- package/dist/write.d.ts.map +1 -1
- package/dist/write.js +21 -30
- package/package.json +2 -2
- package/dist/gather.d.ts +0 -4
- package/dist/gather.d.ts.map +0 -1
- package/dist/gather.js +0 -35
- package/dist/part.d.ts +0 -15
- package/dist/part.d.ts.map +0 -1
- package/dist/part.js +0 -82
package/dist/adapter.js
CHANGED
|
@@ -1,210 +1,124 @@
|
|
|
1
1
|
import { stepped } from '@agentshouse/mdruntime';
|
|
2
|
-
import {
|
|
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 {
|
|
7
|
-
import {
|
|
8
|
-
import {
|
|
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 {
|
|
12
|
-
import {
|
|
13
|
-
import {
|
|
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,
|
|
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
|
|
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
|
|
56
|
-
|
|
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
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
for (
|
|
71
|
-
|
|
72
|
-
|
|
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
|
-
...(
|
|
125
|
-
|
|
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
|
-
|
|
131
|
-
const
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
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
|
|
149
|
-
const
|
|
150
|
-
if (
|
|
151
|
-
return
|
|
152
|
-
const
|
|
153
|
-
if (
|
|
154
|
-
|
|
155
|
-
|
|
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
|
|
164
|
-
|
|
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
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
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
|
-
|
|
174
|
-
|
|
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
|
|
178
|
-
const
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
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
|
-
|
|
190
|
-
|
|
191
|
-
|
|
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
|
-
|
|
115
|
+
notifications.send(rooms);
|
|
194
116
|
}
|
|
195
|
-
async function
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
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(
|
|
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(
|
|
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
|
|
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(
|
|
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
|
-
|
|
499
|
-
|
|
500
|
-
|
|
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
|
|
542
|
-
return
|
|
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(
|
|
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
|
|
582
|
-
|
|
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,
|