@agentshouse/mdruntime-adapter 0.1.0-cdc1a38081f09 → 0.1.0-cdd3671d36a47
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 +2 -2
- 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 +160 -358
- package/dist/app-reference.d.ts +2 -0
- package/dist/app-reference.d.ts.map +1 -0
- package/dist/app-reference.js +2 -0
- 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/crockford.d.ts +4 -0
- package/dist/crockford.d.ts.map +1 -0
- package/dist/crockford.js +3 -0
- package/dist/discovery.d.ts +23 -15
- package/dist/discovery.d.ts.map +1 -1
- package/dist/discovery.js +79 -56
- 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 +710 -0
- package/dist/house-model.d.ts.map +1 -0
- package/dist/house-model.js +417 -0
- package/dist/index.d.ts +10 -2
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +10 -2
- package/dist/model.d.ts +5 -8
- package/dist/model.d.ts.map +1 -1
- package/dist/model.js +32 -46
- 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 +4 -5
- package/dist/room-types.d.ts +2 -3
- package/dist/room-types.d.ts.map +1 -1
- package/dist/room-types.js +49 -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 +77 -167
- 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 -36
- 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 -1
- package/dist/write.d.ts.map +1 -1
- package/dist/write.js +21 -30
- package/package.json +7 -3
- package/AGENTS.md +0 -317
- 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';
|
|
15
|
-
import {
|
|
16
|
-
import {
|
|
14
|
+
import { admittedPath } from './authored-path.js';
|
|
15
|
+
import { HOUSE_TYPED_PATHS } from './house-model.js';
|
|
16
|
+
import { HOUSE_NAMEABLE_ROOM_TYPES, HOUSE_ROOM_TYPES } from './room-types.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
|
|
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
|
-
...entry.schemas.filter((schema) => scope.files.some((file) => file.path === 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)),
|
|
@@ -380,11 +196,13 @@ export function createAgentsHouseAdapter(options) {
|
|
|
380
196
|
: { body: inline };
|
|
381
197
|
if ('outcome' in prepared)
|
|
382
198
|
return prepared.outcome;
|
|
383
|
-
const answer = await transport.door(
|
|
199
|
+
const answer = await transport.door(houseDoorRoute('files/batch'), prepared.body);
|
|
384
200
|
const stagedFiles = await staged(answer, request);
|
|
385
201
|
if (stagedFiles === false)
|
|
386
202
|
return UNCERTAIN;
|
|
387
|
-
const settled = stagedFiles === null
|
|
203
|
+
const settled = stagedFiles === null
|
|
204
|
+
? answer
|
|
205
|
+
: await transport.door(houseDoorRoute('files/batch'), prepared.body);
|
|
388
206
|
if (stagedFiles === true && (await staged(settled, request)) !== null)
|
|
389
207
|
return UNCERTAIN;
|
|
390
208
|
return stepped(mutationOutcome(settled.status, settled.body, entry.locator, entry.handle, into === undefined
|
|
@@ -412,9 +230,22 @@ export function createAgentsHouseAdapter(options) {
|
|
|
412
230
|
function linked(answer, locator) {
|
|
413
231
|
const address = addressed(answer, locator);
|
|
414
232
|
return address.kind === 'address'
|
|
415
|
-
? { kind: 'link', url: address.url, name: address.name }
|
|
233
|
+
? { kind: 'link', url: address.url, name: address.name, mediaType: address.mediaType }
|
|
416
234
|
: address;
|
|
417
235
|
}
|
|
236
|
+
function refusedAttach(answer, locator) {
|
|
237
|
+
const failure = classifyDoor(answer.status, answer.body, locator);
|
|
238
|
+
if (failure === null)
|
|
239
|
+
return null;
|
|
240
|
+
return failure.kind === 'scoped-refusal'
|
|
241
|
+
? {
|
|
242
|
+
kind: 'rejected',
|
|
243
|
+
code: failure.code,
|
|
244
|
+
fields: failure.fields,
|
|
245
|
+
retryable: failure.retryable,
|
|
246
|
+
}
|
|
247
|
+
: failure;
|
|
248
|
+
}
|
|
418
249
|
async function downloaded(ask, locator) {
|
|
419
250
|
let address = addressed(await ask(), locator);
|
|
420
251
|
if (address.kind !== 'address')
|
|
@@ -439,7 +270,7 @@ export function createAgentsHouseAdapter(options) {
|
|
|
439
270
|
const entry = authorityFor(request.locator);
|
|
440
271
|
if (entry === undefined)
|
|
441
272
|
return null;
|
|
442
|
-
return () => transport.door(
|
|
273
|
+
return () => transport.door(houseDoorRoute('files/read'), {
|
|
443
274
|
room_ref: entry.authority,
|
|
444
275
|
path: request.path,
|
|
445
276
|
revision: request.revision,
|
|
@@ -447,72 +278,21 @@ export function createAgentsHouseAdapter(options) {
|
|
|
447
278
|
}
|
|
448
279
|
return {
|
|
449
280
|
roomTypes: HOUSE_ROOM_TYPES,
|
|
281
|
+
nameableRoomTypes: HOUSE_NAMEABLE_ROOM_TYPES,
|
|
282
|
+
typedPaths: HOUSE_TYPED_PATHS,
|
|
283
|
+
pathRule: admittedPath,
|
|
284
|
+
unkeptReads: HOUSE_UNKEPT_READS,
|
|
285
|
+
leadingReads: HOUSE_LEADING_READS,
|
|
450
286
|
async authorize() {
|
|
451
287
|
return options.authorize();
|
|
452
288
|
},
|
|
453
|
-
async discover(_authorization, scope) {
|
|
454
|
-
const answer = await transport.door(DOOR_DISCOVER, {
|
|
455
|
-
prefixes: [...DISCOVER_PREFIXES],
|
|
456
|
-
...(scope === undefined ? {} : { rooms: scope.authorities }),
|
|
457
|
-
});
|
|
458
|
-
const failed = discoveryFailure(answer.status, answer.body);
|
|
459
|
-
if (failed !== null)
|
|
460
|
-
return failed;
|
|
461
|
-
const document = parseDiscovery(answer.body);
|
|
462
|
-
if (document === null)
|
|
463
|
-
return { kind: 'transport-uncertainty' };
|
|
464
|
-
bounds = document.bounds;
|
|
465
|
-
const entries = trackedFrom(document);
|
|
466
|
-
const covered = scope === undefined
|
|
467
|
-
? null
|
|
468
|
-
: [
|
|
469
|
-
...new Set([
|
|
470
|
-
...[...tracked.values()]
|
|
471
|
-
.filter((entry) => scope.authorities.includes(entry.authority))
|
|
472
|
-
.map((entry) => entry.locator),
|
|
473
|
-
...entries.map((entry) => entry.locator),
|
|
474
|
-
]),
|
|
475
|
-
];
|
|
476
|
-
if (covered === null)
|
|
477
|
-
tracked.clear();
|
|
478
|
-
else
|
|
479
|
-
for (const locator of covered)
|
|
480
|
-
tracked.delete(locator);
|
|
481
|
-
for (const entry of entries)
|
|
482
|
-
tracked.set(entry.locator, entry);
|
|
483
|
-
for (const locator of handed.keys())
|
|
484
|
-
if (!tracked.has(locator))
|
|
485
|
-
handed.delete(locator);
|
|
486
|
-
notifications.track([...tracked.values()]);
|
|
487
|
-
return {
|
|
488
|
-
...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document.actions, [...tracked.values()])),
|
|
489
|
-
member: document.member,
|
|
490
|
-
...(covered === null ? {} : { covered }),
|
|
491
|
-
};
|
|
492
|
-
},
|
|
493
289
|
async bootstrap(_authorization, request) {
|
|
494
290
|
const entry = authorityFor(request.locator);
|
|
495
291
|
if (entry === undefined)
|
|
496
292
|
return { kind: 'room-not-readable', locator: request.locator };
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
}
|
|
501
|
-
return bootstrapTogether(asked);
|
|
502
|
-
},
|
|
503
|
-
async refresh(_authorization, request) {
|
|
504
|
-
const entry = authorityFor(request.locator);
|
|
505
|
-
if (entry === undefined)
|
|
506
|
-
return { kind: 'room-not-readable', locator: request.locator };
|
|
507
|
-
if (request.pageToken !== undefined)
|
|
508
|
-
return { kind: 'transport-uncertainty' };
|
|
509
|
-
const from = logPosition(request.fromRoomVersion);
|
|
510
|
-
if (from === null)
|
|
511
|
-
return { kind: 'beyond-horizon' };
|
|
512
|
-
const answered = await streamed(entry, request, from);
|
|
513
|
-
if (answered !== null)
|
|
514
|
-
return answered;
|
|
515
|
-
return enumerateTogether({ entry, from, fromRoomVersion: request.fromRoomVersion });
|
|
293
|
+
return request.pageToken === undefined
|
|
294
|
+
? listedRoom(entry)
|
|
295
|
+
: chunkPage(entry, request.pageToken, request.arriving);
|
|
516
296
|
},
|
|
517
297
|
async mutate(_authorization, request, keep) {
|
|
518
298
|
const entry = authorityFor(request.locator);
|
|
@@ -529,22 +309,21 @@ export function createAgentsHouseAdapter(options) {
|
|
|
529
309
|
: houseMove(batch, entry.handle, into.handle);
|
|
530
310
|
if (mapped.kind === 'unmapped')
|
|
531
311
|
return rejectedMapping(mapped);
|
|
532
|
-
const head = operationHead(batch);
|
|
312
|
+
const head = operationHead(batch, entry.authority);
|
|
533
313
|
const delta = deltaBody(mapped.changes);
|
|
534
314
|
const bytes = deltaBytes(delta);
|
|
535
315
|
const handed = request.upload;
|
|
536
316
|
const answer = (upload) => submit(request, head, mapped.changes, delta, bytes, entry, upload, keep, into);
|
|
537
|
-
const settle = (outcome) => into === undefined ? adopted(entry, outcome) : adoptedMove(entry, into, outcome);
|
|
538
317
|
const outcome = await answer(handed);
|
|
539
318
|
if (handed === undefined || !lapsedGrant(outcome))
|
|
540
|
-
return
|
|
541
|
-
return
|
|
319
|
+
return outcome;
|
|
320
|
+
return answer(undefined);
|
|
542
321
|
},
|
|
543
322
|
async history(_authorization, request) {
|
|
544
323
|
const entry = authorityFor(request.locator);
|
|
545
324
|
if (entry === undefined)
|
|
546
325
|
return { kind: 'room-not-readable', locator: request.locator };
|
|
547
|
-
const answer = await transport.door(
|
|
326
|
+
const answer = await transport.door(houseDoorRoute('files/revisions/list'), revisionBody({
|
|
548
327
|
path: request.path,
|
|
549
328
|
handle: entry.handle,
|
|
550
329
|
...(request.revision === undefined ? {} : { revision: request.revision }),
|
|
@@ -567,6 +346,35 @@ export function createAgentsHouseAdapter(options) {
|
|
|
567
346
|
return { kind: 'room-not-readable', locator: request.locator };
|
|
568
347
|
return linked(await ask(), request.locator);
|
|
569
348
|
},
|
|
349
|
+
async attach(_authorization, request) {
|
|
350
|
+
const entry = authorityFor(request.locator);
|
|
351
|
+
if (entry === undefined)
|
|
352
|
+
return { kind: 'room-not-readable', locator: request.locator };
|
|
353
|
+
const declared = await transport.door(houseDoorRoute('files/attach'), {
|
|
354
|
+
room_ref: entry.authority,
|
|
355
|
+
name: request.name,
|
|
356
|
+
bytes: request.byteLength,
|
|
357
|
+
sha256: request.sha256,
|
|
358
|
+
media_type: request.mediaType.length > 0 ? request.mediaType : OCTET_STREAM,
|
|
359
|
+
});
|
|
360
|
+
const refused = refusedAttach(declared, request.locator);
|
|
361
|
+
if (refused !== null)
|
|
362
|
+
return refused;
|
|
363
|
+
const upload = houseUpload(declared.body?.upload);
|
|
364
|
+
if (upload === null)
|
|
365
|
+
return UNCERTAIN_READ;
|
|
366
|
+
const finished = await finishedUpload(transport, upload, request.blob);
|
|
367
|
+
if (finished === null)
|
|
368
|
+
return UNCERTAIN_READ;
|
|
369
|
+
const unfinished = refusedAttach(finished, request.locator);
|
|
370
|
+
if (unfinished !== null)
|
|
371
|
+
return unfinished;
|
|
372
|
+
const { path, revision } = (finished.body ?? {});
|
|
373
|
+
const root = `/rooms/${entry.handle}/`;
|
|
374
|
+
return typeof path === 'string' && path.startsWith(root) && typeof revision === 'string'
|
|
375
|
+
? { kind: 'attached', path: path.slice(root.length), revision }
|
|
376
|
+
: UNCERTAIN_READ;
|
|
377
|
+
},
|
|
570
378
|
reached(locator, version, target) {
|
|
571
379
|
return reachedVersion(version, target, authorityFor(locator)?.logEpoch);
|
|
572
380
|
},
|
|
@@ -576,18 +384,12 @@ export function createAgentsHouseAdapter(options) {
|
|
|
576
384
|
async action(_authorization, request) {
|
|
577
385
|
return withAt(await houseAction(transport, request));
|
|
578
386
|
},
|
|
387
|
+
search(_authorization, request) {
|
|
388
|
+
return houseSearch(transport, [...tracked.values()], request);
|
|
389
|
+
},
|
|
579
390
|
roomStream: {
|
|
580
|
-
hold
|
|
581
|
-
|
|
582
|
-
observe(notify, receipts, revisions) {
|
|
583
|
-
heldRevisions = revisions;
|
|
584
|
-
return notifications.observe(notify, receipts);
|
|
585
|
-
},
|
|
586
|
-
published(locator, roomVersion) {
|
|
587
|
-
const at = logPosition(roomVersion);
|
|
588
|
-
if (at !== null)
|
|
589
|
-
notifications.published(locator, at);
|
|
590
|
-
},
|
|
391
|
+
hold,
|
|
392
|
+
observe: notifications.observe,
|
|
591
393
|
},
|
|
592
394
|
conversations: notifications.conversations,
|
|
593
395
|
serviceMode: notifications.serviceMode,
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"app-reference.d.ts","sourceRoot":"","sources":["../src/app-reference.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,qBAAqB,QAEjC,CAAC"}
|