@agentshouse/mdruntime-adapter 0.1.0-cb9b1f8bb3e9a → 0.1.0-cbba19a6c37ed
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 +3 -3
- package/dist/actions.d.ts +6 -67
- package/dist/actions.d.ts.map +1 -1
- package/dist/actions.js +23 -340
- package/dist/adapter.d.ts +0 -1
- package/dist/adapter.d.ts.map +1 -1
- package/dist/adapter.js +246 -371
- package/dist/app-reference.d.ts +1 -0
- package/dist/app-reference.d.ts.map +1 -0
- package/dist/app-reference.js +2 -0
- package/dist/authored-path.d.ts +10 -0
- package/dist/authored-path.d.ts.map +1 -0
- package/dist/authored-path.js +35 -0
- package/dist/chunks.d.ts +37 -0
- package/dist/chunks.d.ts.map +1 -0
- package/dist/chunks.js +247 -0
- package/dist/crockford.d.ts +3 -0
- package/dist/crockford.d.ts.map +1 -0
- package/dist/crockford.js +3 -0
- package/dist/digest.d.ts +0 -1
- package/dist/discovery.d.ts +24 -18
- package/dist/discovery.d.ts.map +1 -1
- package/dist/discovery.js +96 -57
- package/dist/history.d.ts +11 -0
- package/dist/history.d.ts.map +1 -0
- package/dist/history.js +92 -0
- package/dist/house-model.d.ts +697 -0
- package/dist/house-model.d.ts.map +1 -0
- package/dist/house-model.js +405 -0
- package/dist/index.d.ts +12 -3
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +11 -1
- package/dist/map.d.ts +0 -1
- package/dist/model.d.ts +5 -5
- package/dist/model.d.ts.map +1 -1
- package/dist/model.js +34 -41
- package/dist/read.d.ts +58 -63
- package/dist/read.d.ts.map +1 -1
- package/dist/read.js +156 -310
- package/dist/refusal.d.ts +1 -4
- package/dist/refusal.d.ts.map +1 -1
- package/dist/refusal.js +5 -6
- package/dist/room-types.d.ts +4 -0
- package/dist/room-types.d.ts.map +1 -0
- package/dist/room-types.js +120 -0
- package/dist/search.d.ts +4 -0
- package/dist/search.d.ts.map +1 -0
- package/dist/search.js +47 -0
- package/dist/session-content/bounds.d.ts +7 -0
- package/dist/session-content/check.d.ts +18 -0
- package/dist/session-content/index.d.ts +7 -0
- package/dist/session-content/parts.d.ts +102 -0
- package/dist/session-content/state.d.ts +61 -0
- package/dist/session-content/turn.d.ts +328 -0
- package/dist/site.d.ts +0 -1
- package/dist/site.d.ts.map +1 -1
- package/dist/site.js +102 -202
- package/dist/space-schema.d.ts +6 -0
- package/dist/space-schema.d.ts.map +1 -0
- package/dist/space-schema.js +18 -0
- package/dist/stream.d.ts +16 -16
- package/dist/stream.d.ts.map +1 -1
- package/dist/stream.js +258 -422
- package/dist/transport.d.ts +79 -48
- package/dist/transport.d.ts.map +1 -1
- package/dist/transport.js +54 -11
- package/dist/upload.d.ts +11 -0
- package/dist/upload.d.ts.map +1 -0
- package/dist/upload.js +63 -0
- package/dist/version.d.ts +0 -1
- package/dist/write.d.ts +18 -4
- package/dist/write.d.ts.map +1 -1
- package/dist/write.js +108 -79
- package/package.json +8 -4
- package/AGENTS.md +0 -300
- package/dist/gather.d.ts +0 -4
- package/dist/gather.d.ts.map +0 -1
- package/dist/gather.js +0 -45
- package/dist/handed.d.ts +0 -15
- package/dist/handed.d.ts.map +0 -1
- package/dist/handed.js +0 -38
- package/dist/referrer.d.ts +0 -7
- package/dist/referrer.d.ts.map +0 -1
- package/dist/referrer.js +0 -35
package/dist/adapter.js
CHANGED
|
@@ -1,171 +1,124 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import {
|
|
3
|
-
import { gathered, gatheredEach, selections } from './gather.js';
|
|
1
|
+
import { stepped } from '@agentshouse/mdruntime';
|
|
2
|
+
import { capabilities, discoveredRoom, mapDiscovery, parseAuthorityChange, parseDiscovery, trackedFrom, } from './discovery.js';
|
|
4
3
|
import { createSiteAdapter } from './site.js';
|
|
5
|
-
import {
|
|
6
|
-
import {
|
|
7
|
-
import {
|
|
8
|
-
import {
|
|
9
|
-
import {
|
|
10
|
-
import {
|
|
11
|
-
import {
|
|
12
|
-
import {
|
|
13
|
-
import {
|
|
14
|
-
import {
|
|
4
|
+
import { parseFileAddress, parseGrant } from './read.js';
|
|
5
|
+
import { chunkedHead, chunkLister, chunkPart } from './chunks.js';
|
|
6
|
+
import { spaceSchemas } from './space-schema.js';
|
|
7
|
+
import { finishedUpload, houseUpload } from './upload.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';
|
|
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';
|
|
16
|
+
import { HOUSE_NAMEABLE_ROOM_TYPES, HOUSE_ROOM_TYPES } from './room-types.js';
|
|
17
|
+
import { followsVersion, reachedVersion, roomVersion } from './version.js';
|
|
15
18
|
const UNCERTAIN = { kind: 'transport-uncertainty' };
|
|
16
19
|
const UNCERTAIN_READ = { kind: 'transport-uncertainty' };
|
|
20
|
+
const OCTET_STREAM = 'application/octet-stream';
|
|
21
|
+
const EXPIRED_ADDRESS = 403;
|
|
17
22
|
function lapsedGrant(outcome) {
|
|
18
23
|
return outcome.kind === 'rejected' && outcome.code === 'upload_unavailable';
|
|
19
24
|
}
|
|
20
|
-
function heldFiles(authority, held, after, budget) {
|
|
21
|
-
if (held === undefined || budget === 0)
|
|
22
|
-
return null;
|
|
23
|
-
const paths = Object.keys(held.revisions)
|
|
24
|
-
.filter((path) => held.documents[path] !== undefined && (after === null || path > after))
|
|
25
|
-
.sort();
|
|
26
|
-
if (paths.length === 0)
|
|
27
|
-
return null;
|
|
28
|
-
const files = paths.slice(0, budget).map((path) => ({ path, revision: held.revisions[path] }));
|
|
29
|
-
return { room: authority, through: paths.length > budget ? files.at(-1).path : null, files };
|
|
30
|
-
}
|
|
31
|
-
async function reused(scope, held) {
|
|
32
|
-
const sent = new Set(scope.contents.map((entry) => entry.path));
|
|
33
|
-
const contents = [...scope.contents];
|
|
34
|
-
for (const file of scope.files) {
|
|
35
|
-
if (file.binary !== undefined || sent.has(file.path))
|
|
36
|
-
continue;
|
|
37
|
-
const content = held?.documents[file.path];
|
|
38
|
-
if (content === undefined ||
|
|
39
|
-
held?.revisions[file.path] !== file.revision ||
|
|
40
|
-
(await sha256Hex(content)) !== file.sha256) {
|
|
41
|
-
return null;
|
|
42
|
-
}
|
|
43
|
-
contents.push({ path: file.path, content });
|
|
44
|
-
}
|
|
45
|
-
return { ...scope, contents };
|
|
46
|
-
}
|
|
47
25
|
export function createAgentsHouseAdapter(options) {
|
|
48
26
|
if ('site' in options)
|
|
49
27
|
return createSiteAdapter(options.site, options.snapshot === true);
|
|
50
28
|
const transport = options.transport;
|
|
51
|
-
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);
|
|
52
35
|
const tracked = new Map();
|
|
53
|
-
const
|
|
36
|
+
const lister = chunkLister(transport, () => declared().max_prefixes);
|
|
37
|
+
const chunked = new Map();
|
|
38
|
+
const renewals = new WeakMap();
|
|
54
39
|
let bounds;
|
|
55
40
|
function declared() {
|
|
56
41
|
if (bounds === undefined)
|
|
57
42
|
throw new Error('no Discovery declared the bounds');
|
|
58
43
|
return bounds;
|
|
59
44
|
}
|
|
60
|
-
|
|
61
|
-
const
|
|
62
|
-
if (
|
|
63
|
-
return
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
: continuedBootstrap({ entry, held: undefined }, continued);
|
|
71
|
-
}
|
|
72
|
-
const cursor = envelope.next?.room === entry.authority ? envelope.next : undefined;
|
|
73
|
-
const next = cursor?.path ?? null;
|
|
74
|
-
if (continued === null && next === null)
|
|
75
|
-
handed.set(entry.locator, scopeHanded(scope));
|
|
76
|
-
else
|
|
77
|
-
handed.delete(entry.locator);
|
|
78
|
-
notifications.reach(entry.authority, scope);
|
|
79
|
-
const seen = [
|
|
80
|
-
...(continued?.seen ?? []),
|
|
81
|
-
...entry.schemas.filter((schema) => scope.files.some((file) => file.path === schema)),
|
|
82
|
-
];
|
|
83
|
-
const models = await partModels(scope, entry, new Set(seen), next === null);
|
|
84
|
-
const continuation = next === null
|
|
85
|
-
? null
|
|
86
|
-
: { after: next, seen, ...(cursor?.cut === undefined ? {} : { cut: cursor.cut }) };
|
|
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()]);
|
|
87
55
|
return {
|
|
88
|
-
...
|
|
89
|
-
|
|
90
|
-
...(continuation === null ? {} : { pageToken: JSON.stringify(continuation) }),
|
|
56
|
+
...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document.actions)),
|
|
57
|
+
member: document.member,
|
|
91
58
|
};
|
|
92
59
|
}
|
|
93
|
-
|
|
94
|
-
const
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
return UNCERTAIN_READ;
|
|
109
|
-
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
|
+
};
|
|
110
75
|
}
|
|
111
|
-
async function
|
|
112
|
-
const
|
|
113
|
-
if (
|
|
114
|
-
return
|
|
115
|
-
const
|
|
116
|
-
if (
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
const answer = refreshFrom(view, ask.fromRoomVersion);
|
|
120
|
-
if (answer.kind !== 'net-advancement')
|
|
121
|
-
return answer;
|
|
122
|
-
handed.set(ask.entry.locator, enumeratedHanded(view, handed.get(ask.entry.locator)));
|
|
123
|
-
const models = await viewModels(view, ask.entry);
|
|
124
|
-
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;
|
|
125
84
|
}
|
|
126
|
-
async function
|
|
127
|
-
const
|
|
128
|
-
|
|
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)
|
|
129
89
|
return null;
|
|
130
|
-
const
|
|
131
|
-
if (
|
|
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))
|
|
132
95
|
return null;
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
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) };
|
|
136
98
|
}
|
|
137
|
-
function
|
|
138
|
-
const
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
notifications.reach(entry.authority, at);
|
|
145
|
-
return [presented(entry.authority, at)];
|
|
146
|
-
});
|
|
147
|
-
notifications.send(kept, demand === null
|
|
148
|
-
? null
|
|
149
|
-
: {
|
|
150
|
-
rooms: demand.rooms.flatMap((locator) => {
|
|
151
|
-
const entry = tracked.get(locator);
|
|
152
|
-
return entry === undefined ? [] : [entry.authority];
|
|
153
|
-
}),
|
|
154
|
-
conversations: demand.conversations,
|
|
155
|
-
});
|
|
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;
|
|
156
106
|
}
|
|
157
|
-
function
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
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);
|
|
114
|
+
}
|
|
115
|
+
notifications.send(rooms);
|
|
116
|
+
}
|
|
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);
|
|
169
122
|
}
|
|
170
123
|
function authorityFor(locator) {
|
|
171
124
|
return tracked.get(locator);
|
|
@@ -184,183 +137,81 @@ export function createAgentsHouseAdapter(options) {
|
|
|
184
137
|
return result;
|
|
185
138
|
return { ...result, at: { locator, roomVersion: roomVersion({ position, logEpoch }) } };
|
|
186
139
|
}
|
|
187
|
-
function weight(entry) {
|
|
188
|
-
return contentPrefixes(entry).length;
|
|
189
|
-
}
|
|
190
|
-
function holding(asks, after) {
|
|
191
|
-
const budget = Math.floor(declared().max_held_files / Math.max(1, asks.filter((ask) => ask.held !== undefined).length));
|
|
192
|
-
return asks.flatMap((ask) => heldFiles(ask.entry.authority, ask.held, after, budget) ?? []);
|
|
193
|
-
}
|
|
194
|
-
async function bootstrapped(asks, answer) {
|
|
195
|
-
let open = asks.map((asked, ask) => ({ entry: asked.entry, asked, ask }));
|
|
196
|
-
while (open.length > 0) {
|
|
197
|
-
const unreached = [];
|
|
198
|
-
for (const part of selections(open, ({ entry }) => weight(entry), declared().max_prefixes)) {
|
|
199
|
-
const held = holding(part.map(({ asked }) => asked), null);
|
|
200
|
-
const answered = await transport.door(DOOR_BOOTSTRAP, {
|
|
201
|
-
prefixes: part.flatMap(({ entry }) => contentPrefixes(entry)),
|
|
202
|
-
...(held.length === 0 ? {} : { held }),
|
|
203
|
-
});
|
|
204
|
-
const classified = part.map(({ entry }) => classifyDoor(answered.status, answered.body, entry.locator));
|
|
205
|
-
const envelope = classified[0] === null ? parseEnvelope(answered.body) : null;
|
|
206
|
-
for (const [index, asked] of part.entries()) {
|
|
207
|
-
const failure = classified[index];
|
|
208
|
-
if (failure !== null && failure !== undefined) {
|
|
209
|
-
answer(asked.ask, failure);
|
|
210
|
-
continue;
|
|
211
|
-
}
|
|
212
|
-
if (envelope === null) {
|
|
213
|
-
answer(asked.ask, UNCERTAIN_READ);
|
|
214
|
-
continue;
|
|
215
|
-
}
|
|
216
|
-
const scope = envelope.scopes.find((candidate) => matchesScope(candidate, asked.entry));
|
|
217
|
-
if (scope === undefined && envelope.next !== undefined) {
|
|
218
|
-
unreached.push(asked);
|
|
219
|
-
continue;
|
|
220
|
-
}
|
|
221
|
-
answer(asked.ask, await bootstrappedRoom(envelope, scope, asked.asked, null));
|
|
222
|
-
}
|
|
223
|
-
}
|
|
224
|
-
open = unreached;
|
|
225
|
-
}
|
|
226
|
-
}
|
|
227
|
-
async function continuedBootstrap(asked, continued) {
|
|
228
|
-
const { entry } = asked;
|
|
229
|
-
const after = {
|
|
230
|
-
room: entry.authority,
|
|
231
|
-
path: continued.after,
|
|
232
|
-
...(continued.cut === undefined ? {} : { cut: continued.cut }),
|
|
233
|
-
};
|
|
234
|
-
const held = holding([asked], continued.after);
|
|
235
|
-
const answered = await transport.door(DOOR_BOOTSTRAP, {
|
|
236
|
-
prefixes: contentPrefixes(entry),
|
|
237
|
-
after,
|
|
238
|
-
...(held.length === 0 ? {} : { held }),
|
|
239
|
-
});
|
|
240
|
-
const failure = classifyRead(answered.status, answered.body, entry.locator);
|
|
241
|
-
if (failure !== null)
|
|
242
|
-
return failure;
|
|
243
|
-
const envelope = parseEnvelope(answered.body);
|
|
244
|
-
if (envelope === null)
|
|
245
|
-
return UNCERTAIN_READ;
|
|
246
|
-
const scope = envelope.scopes.find((candidate) => matchesScope(candidate, entry));
|
|
247
|
-
return bootstrappedRoom(envelope, scope, asked, continued);
|
|
248
|
-
}
|
|
249
|
-
function layered(asks) {
|
|
250
|
-
const depths = new Map();
|
|
251
|
-
const layers = [];
|
|
252
|
-
for (const ask of asks) {
|
|
253
|
-
const depth = depths.get(ask.ask.entry.authority) ?? 0;
|
|
254
|
-
depths.set(ask.ask.entry.authority, depth + 1);
|
|
255
|
-
(layers[depth] ??= []).push(ask);
|
|
256
|
-
}
|
|
257
|
-
return layers;
|
|
258
|
-
}
|
|
259
|
-
async function enumerated(asks) {
|
|
260
|
-
const answers = [];
|
|
261
|
-
const parts = layered(asks.map((ask, index) => ({ ask, index }))).flatMap((layer) => selections(layer, ({ ask }) => weight(ask.entry), declared().max_prefixes));
|
|
262
|
-
for (const part of parts) {
|
|
263
|
-
let open = [...part];
|
|
264
|
-
while (open.length > 0) {
|
|
265
|
-
const answer = await transport.door(DOOR_ENUMERATE, {
|
|
266
|
-
prefixes: open.flatMap(({ ask }) => contentPrefixes(ask.entry)),
|
|
267
|
-
positions: open.map(({ ask }) => presented(ask.entry.authority, ask.from)),
|
|
268
|
-
});
|
|
269
|
-
const classified = open.map(({ ask }) => classifyRead(answer.status, answer.body, ask.entry.locator));
|
|
270
|
-
if (classified[0]?.kind === 'beyond-horizon') {
|
|
271
|
-
const named = doorRefusal(answer.body)?.fields.authority;
|
|
272
|
-
const expired = open.filter(({ ask }) => ask.entry.authority === named);
|
|
273
|
-
const answered = expired.length === 0 ? UNCERTAIN_READ : { kind: 'beyond-horizon' };
|
|
274
|
-
const gone = expired.length === 0 ? open : expired;
|
|
275
|
-
for (const ask of gone)
|
|
276
|
-
answers[ask.index] = answered;
|
|
277
|
-
open = open.filter((ask) => !gone.includes(ask));
|
|
278
|
-
continue;
|
|
279
|
-
}
|
|
280
|
-
const enumeration = classified[0] === null ? parseEnumeration(answer.body, 'credential') : null;
|
|
281
|
-
for (const [answerIndex, { ask, index }] of open.entries()) {
|
|
282
|
-
const failure = classified[answerIndex];
|
|
283
|
-
if (failure !== null && failure !== undefined) {
|
|
284
|
-
answers[index] = failure;
|
|
285
|
-
continue;
|
|
286
|
-
}
|
|
287
|
-
answers[index] =
|
|
288
|
-
enumeration === null ? UNCERTAIN_READ : await enumeratedRoom(enumeration, ask);
|
|
289
|
-
}
|
|
290
|
-
open = [];
|
|
291
|
-
}
|
|
292
|
-
}
|
|
293
|
-
return answers;
|
|
294
|
-
}
|
|
295
|
-
const bootstrapTogether = gatheredEach(bootstrapped);
|
|
296
|
-
const enumerateTogether = gathered(enumerated);
|
|
297
140
|
async function uploaded(head, changes, delta, bytes, entry, handed, keep) {
|
|
298
141
|
const paths = batchPaths(changes);
|
|
299
142
|
const sha256 = await deltaDigest(delta);
|
|
300
143
|
if (handed !== undefined && handed.sha256 === sha256) {
|
|
301
144
|
return { body: { ...head, paths, upload: handed, runtime: notifications.runtime } };
|
|
302
145
|
}
|
|
303
|
-
const minted = await transport.door(
|
|
146
|
+
const minted = await transport.door(houseDoorRoute('files/batch-upload'), {
|
|
147
|
+
...head,
|
|
148
|
+
paths,
|
|
149
|
+
bytes,
|
|
150
|
+
sha256,
|
|
151
|
+
});
|
|
304
152
|
if (minted.status !== 200) {
|
|
305
|
-
return {
|
|
153
|
+
return {
|
|
154
|
+
outcome: await stepped(mutationOutcome(minted.status, minted.body, entry.locator, entry.handle)),
|
|
155
|
+
};
|
|
306
156
|
}
|
|
307
157
|
const grant = parseGrant(minted.body);
|
|
308
|
-
if (grant === null
|
|
158
|
+
if (grant === null)
|
|
309
159
|
return { outcome: UNCERTAIN };
|
|
310
160
|
const delivered = await transport.transfer({
|
|
311
|
-
act: 'authored_batch_upload',
|
|
312
161
|
url: grant.url,
|
|
313
162
|
body: `${grant.operation}\n${delta}`,
|
|
314
163
|
});
|
|
315
164
|
if (delivered.status !== 200)
|
|
316
165
|
return { outcome: UNCERTAIN };
|
|
317
166
|
const holding = parseGrant(delivered.body);
|
|
318
|
-
if (holding === null
|
|
167
|
+
if (holding === null)
|
|
319
168
|
return { outcome: UNCERTAIN };
|
|
320
169
|
const upload = { url: holding.url, operation: holding.operation, bytes, sha256 };
|
|
321
170
|
await keep(upload);
|
|
322
171
|
return { body: { ...head, paths, upload, runtime: notifications.runtime } };
|
|
323
172
|
}
|
|
324
|
-
async function staged(answer, batch) {
|
|
173
|
+
async function staged(answer, { changeBatch: batch, file }) {
|
|
325
174
|
const refusal = doorRefusal(answer.body);
|
|
326
175
|
if (refusal?.code !== 'files_unstaged')
|
|
327
176
|
return null;
|
|
328
|
-
const
|
|
329
|
-
if (!Array.isArray(
|
|
177
|
+
const uploads = refusal.fields.upload;
|
|
178
|
+
if (!Array.isArray(uploads))
|
|
330
179
|
return false;
|
|
331
|
-
for (const
|
|
332
|
-
const
|
|
333
|
-
const change = batch.changes.find((held) => held.kind === 'binary' && held.sha256 === sha256);
|
|
334
|
-
if (
|
|
180
|
+
for (const named of uploads) {
|
|
181
|
+
const upload = houseUpload(named);
|
|
182
|
+
const change = batch.changes.find((held) => held.kind === 'binary' && held.sha256 === named.sha256);
|
|
183
|
+
if (upload === null || change === undefined)
|
|
335
184
|
return false;
|
|
336
|
-
const
|
|
337
|
-
|
|
338
|
-
url,
|
|
339
|
-
body: change.blob,
|
|
340
|
-
operation,
|
|
341
|
-
});
|
|
342
|
-
if (delivered.status !== 200)
|
|
185
|
+
const finished = await finishedUpload(transport, upload, await file(change.localId));
|
|
186
|
+
if (finished?.body?.staged !== true)
|
|
343
187
|
return false;
|
|
344
188
|
}
|
|
345
189
|
return true;
|
|
346
190
|
}
|
|
347
|
-
async function submit(
|
|
191
|
+
async function submit(request, head, changes, delta, bytes, entry, handed, keep, into) {
|
|
348
192
|
const inline = { ...head, changes, runtime: notifications.runtime };
|
|
349
193
|
const prepared = uploadable(inline, bytes, declared())
|
|
350
194
|
? await uploaded(head, changes, delta, bytes, entry, handed, keep)
|
|
351
195
|
: { body: inline };
|
|
352
196
|
if ('outcome' in prepared)
|
|
353
197
|
return prepared.outcome;
|
|
354
|
-
const answer = await transport.door(
|
|
355
|
-
const stagedFiles = await staged(answer,
|
|
198
|
+
const answer = await transport.door(houseDoorRoute('files/batch'), prepared.body);
|
|
199
|
+
const stagedFiles = await staged(answer, request);
|
|
356
200
|
if (stagedFiles === false)
|
|
357
201
|
return UNCERTAIN;
|
|
358
|
-
const settled = stagedFiles === null
|
|
359
|
-
|
|
202
|
+
const settled = stagedFiles === null
|
|
203
|
+
? answer
|
|
204
|
+
: await transport.door(houseDoorRoute('files/batch'), prepared.body);
|
|
205
|
+
if (stagedFiles === true && (await staged(settled, request)) !== null)
|
|
360
206
|
return UNCERTAIN;
|
|
361
|
-
return mutationOutcome(settled.status, settled.body, entry.locator, entry.handle
|
|
207
|
+
return stepped(mutationOutcome(settled.status, settled.body, entry.locator, entry.handle, into === undefined
|
|
208
|
+
? undefined
|
|
209
|
+
: {
|
|
210
|
+
source: { authority: entry.authority, handle: entry.handle },
|
|
211
|
+
destination: { authority: into.authority, handle: into.handle },
|
|
212
|
+
}));
|
|
362
213
|
}
|
|
363
|
-
|
|
214
|
+
function addressed(answer, locator) {
|
|
364
215
|
const failure = classifyDoor(answer.status, answer.body, locator);
|
|
365
216
|
if (failure !== null) {
|
|
366
217
|
return failure.kind === 'scoped-refusal'
|
|
@@ -372,126 +223,153 @@ export function createAgentsHouseAdapter(options) {
|
|
|
372
223
|
}
|
|
373
224
|
: failure;
|
|
374
225
|
}
|
|
375
|
-
const
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
226
|
+
const address = parseFileAddress(answer.body);
|
|
227
|
+
return address === null ? UNCERTAIN_READ : { kind: 'address', ...address };
|
|
228
|
+
}
|
|
229
|
+
function linked(answer, locator) {
|
|
230
|
+
const address = addressed(answer, locator);
|
|
231
|
+
return address.kind === 'address'
|
|
232
|
+
? { kind: 'link', url: address.url, name: address.name, mediaType: address.mediaType }
|
|
233
|
+
: address;
|
|
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
|
+
}
|
|
248
|
+
async function downloaded(ask, locator) {
|
|
249
|
+
let address = addressed(await ask(), locator);
|
|
250
|
+
if (address.kind !== 'address')
|
|
251
|
+
return address;
|
|
252
|
+
let read = await transport.download(address.url);
|
|
253
|
+
if (read.status === EXPIRED_ADDRESS) {
|
|
254
|
+
address = addressed(await ask(), locator);
|
|
255
|
+
if (address.kind !== 'address')
|
|
256
|
+
return address;
|
|
257
|
+
read = await transport.download(address.url);
|
|
258
|
+
}
|
|
259
|
+
if (read.status !== 200 || read.body === null)
|
|
380
260
|
return UNCERTAIN_READ;
|
|
381
|
-
return {
|
|
261
|
+
return {
|
|
262
|
+
kind: 'binary',
|
|
263
|
+
body: read.body,
|
|
264
|
+
mediaType: address.mediaType,
|
|
265
|
+
sha256: address.sha256,
|
|
266
|
+
};
|
|
267
|
+
}
|
|
268
|
+
function pathAddress(request) {
|
|
269
|
+
const entry = authorityFor(request.locator);
|
|
270
|
+
if (entry === undefined)
|
|
271
|
+
return null;
|
|
272
|
+
return () => transport.door(houseDoorRoute('files/read'), {
|
|
273
|
+
room_ref: entry.authority,
|
|
274
|
+
path: request.path,
|
|
275
|
+
revision: request.revision,
|
|
276
|
+
});
|
|
382
277
|
}
|
|
383
278
|
return {
|
|
279
|
+
roomTypes: HOUSE_ROOM_TYPES,
|
|
280
|
+
nameableRoomTypes: HOUSE_NAMEABLE_ROOM_TYPES,
|
|
281
|
+
typedPaths: HOUSE_TYPED_PATHS,
|
|
282
|
+
pathRule: admittedPath,
|
|
283
|
+
unkeptReads: HOUSE_UNKEPT_READS,
|
|
284
|
+
leadingReads: HOUSE_LEADING_READS,
|
|
384
285
|
async authorize() {
|
|
385
286
|
return options.authorize();
|
|
386
287
|
},
|
|
387
|
-
async discover(_authorization) {
|
|
388
|
-
const answer = await transport.door(DOOR_DISCOVER, { prefixes: [...DISCOVER_PREFIXES] });
|
|
389
|
-
const failed = discoveryFailure(answer.status, answer.body);
|
|
390
|
-
if (failed !== null)
|
|
391
|
-
return failed;
|
|
392
|
-
const document = parseDiscovery(answer.body);
|
|
393
|
-
if (document === null)
|
|
394
|
-
return { kind: 'transport-uncertainty' };
|
|
395
|
-
bounds = document.bounds;
|
|
396
|
-
const entries = trackedFrom(document);
|
|
397
|
-
tracked.clear();
|
|
398
|
-
for (const entry of entries)
|
|
399
|
-
tracked.set(entry.locator, entry);
|
|
400
|
-
for (const locator of handed.keys())
|
|
401
|
-
if (!tracked.has(locator))
|
|
402
|
-
handed.delete(locator);
|
|
403
|
-
notifications.track(entries);
|
|
404
|
-
return {
|
|
405
|
-
...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document)),
|
|
406
|
-
member: document.member,
|
|
407
|
-
};
|
|
408
|
-
},
|
|
409
288
|
async bootstrap(_authorization, request) {
|
|
410
289
|
const entry = authorityFor(request.locator);
|
|
411
290
|
if (entry === undefined)
|
|
412
291
|
return { kind: 'room-not-readable', locator: request.locator };
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
}
|
|
417
|
-
return bootstrapTogether(asked);
|
|
418
|
-
},
|
|
419
|
-
async refresh(_authorization, request) {
|
|
420
|
-
const entry = authorityFor(request.locator);
|
|
421
|
-
if (entry === undefined)
|
|
422
|
-
return { kind: 'room-not-readable', locator: request.locator };
|
|
423
|
-
if (request.pageToken !== undefined)
|
|
424
|
-
return { kind: 'transport-uncertainty' };
|
|
425
|
-
const from = logPosition(request.fromRoomVersion);
|
|
426
|
-
if (from === null)
|
|
427
|
-
return { kind: 'beyond-horizon' };
|
|
428
|
-
const answered = await streamed(entry, request, from);
|
|
429
|
-
if (answered !== null)
|
|
430
|
-
return answered;
|
|
431
|
-
return enumerateTogether({ entry, from, fromRoomVersion: request.fromRoomVersion });
|
|
292
|
+
return request.pageToken === undefined
|
|
293
|
+
? listedRoom(entry)
|
|
294
|
+
: chunkPage(entry, request.pageToken, request.arriving);
|
|
432
295
|
},
|
|
433
296
|
async mutate(_authorization, request, keep) {
|
|
434
297
|
const entry = authorityFor(request.locator);
|
|
435
298
|
if (entry === undefined)
|
|
436
299
|
return { kind: 'room-not-readable', locator: request.locator };
|
|
437
|
-
const
|
|
300
|
+
const batch = request.changeBatch;
|
|
301
|
+
const destination = batch.between?.destination.room;
|
|
302
|
+
const into = destination === undefined ? undefined : authorityFor(destination);
|
|
303
|
+
if (destination !== undefined && into === undefined) {
|
|
304
|
+
return { kind: 'room-not-readable', locator: destination };
|
|
305
|
+
}
|
|
306
|
+
const mapped = into === undefined
|
|
307
|
+
? houseChanges(batch, entry.handle)
|
|
308
|
+
: houseMove(batch, entry.handle, into.handle);
|
|
438
309
|
if (mapped.kind === 'unmapped')
|
|
439
310
|
return rejectedMapping(mapped);
|
|
440
|
-
const head = operationHead(
|
|
311
|
+
const head = operationHead(batch, entry.authority);
|
|
441
312
|
const delta = deltaBody(mapped.changes);
|
|
442
313
|
const bytes = deltaBytes(delta);
|
|
443
314
|
const handed = request.upload;
|
|
444
|
-
const
|
|
445
|
-
const outcome = await
|
|
315
|
+
const answer = (upload) => submit(request, head, mapped.changes, delta, bytes, entry, upload, keep, into);
|
|
316
|
+
const outcome = await answer(handed);
|
|
446
317
|
if (handed === undefined || !lapsedGrant(outcome))
|
|
447
|
-
return
|
|
448
|
-
return
|
|
318
|
+
return outcome;
|
|
319
|
+
return answer(undefined);
|
|
449
320
|
},
|
|
450
321
|
async history(_authorization, request) {
|
|
451
322
|
const entry = authorityFor(request.locator);
|
|
452
323
|
if (entry === undefined)
|
|
453
324
|
return { kind: 'room-not-readable', locator: request.locator };
|
|
454
|
-
const answer = await transport.door(
|
|
325
|
+
const answer = await transport.door(houseDoorRoute('files/revisions/list'), revisionBody({
|
|
455
326
|
path: request.path,
|
|
456
327
|
handle: entry.handle,
|
|
457
328
|
...(request.revision === undefined ? {} : { revision: request.revision }),
|
|
458
329
|
...(request.pageToken === undefined ? {} : { pageToken: request.pageToken }),
|
|
459
330
|
}));
|
|
460
|
-
return historyOutcome(answer.status, answer.body, entry.locator,
|
|
461
|
-
path: request.path,
|
|
462
|
-
...(request.revision === undefined ? {} : { revision: request.revision }),
|
|
463
|
-
});
|
|
331
|
+
return historyOutcome(answer.status, answer.body, entry.locator, request);
|
|
464
332
|
},
|
|
465
333
|
async binary(_authorization, request) {
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
const answer = await transport.door(DOOR_FILES_GET, {
|
|
471
|
-
room_ref: entry.authority,
|
|
472
|
-
path: request.path,
|
|
473
|
-
revision: request.revision,
|
|
474
|
-
});
|
|
475
|
-
return downloaded(answer, request.locator);
|
|
476
|
-
}
|
|
477
|
-
const referrer = houseReferrer(request.referrer, tracked);
|
|
478
|
-
if (referrer === null) {
|
|
479
|
-
return { kind: 'rejected', code: 'referrer_unknown', fields: {}, retryable: false };
|
|
480
|
-
}
|
|
481
|
-
const answer = await transport.door(DOOR_FILES_GET, {
|
|
482
|
-
file: request.fileRef,
|
|
483
|
-
referrer: referrer.referrer,
|
|
484
|
-
});
|
|
485
|
-
return downloaded(answer, referrer.locator);
|
|
334
|
+
const ask = pathAddress(request);
|
|
335
|
+
if (ask === null)
|
|
336
|
+
return { kind: 'room-not-readable', locator: request.locator };
|
|
337
|
+
return downloaded(ask, request.locator);
|
|
486
338
|
},
|
|
487
|
-
|
|
488
|
-
const
|
|
489
|
-
if (
|
|
490
|
-
return
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
339
|
+
async link(_authorization, request) {
|
|
340
|
+
const ask = pathAddress(request);
|
|
341
|
+
if (ask === null)
|
|
342
|
+
return { kind: 'room-not-readable', locator: request.locator };
|
|
343
|
+
return linked(await ask(), request.locator);
|
|
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;
|
|
495
373
|
},
|
|
496
374
|
reached(locator, version, target) {
|
|
497
375
|
return reachedVersion(version, target, authorityFor(locator)?.logEpoch);
|
|
@@ -502,15 +380,12 @@ export function createAgentsHouseAdapter(options) {
|
|
|
502
380
|
async action(_authorization, request) {
|
|
503
381
|
return withAt(await houseAction(transport, request));
|
|
504
382
|
},
|
|
383
|
+
search(_authorization, request) {
|
|
384
|
+
return houseSearch(transport, [...tracked.values()], request);
|
|
385
|
+
},
|
|
505
386
|
roomStream: {
|
|
506
|
-
hold
|
|
507
|
-
reopen: notifications.reopen,
|
|
387
|
+
hold,
|
|
508
388
|
observe: notifications.observe,
|
|
509
|
-
published(locator, roomVersion) {
|
|
510
|
-
const at = logPosition(roomVersion);
|
|
511
|
-
if (at !== null)
|
|
512
|
-
notifications.published(locator, at);
|
|
513
|
-
},
|
|
514
389
|
},
|
|
515
390
|
conversations: notifications.conversations,
|
|
516
391
|
serviceMode: notifications.serviceMode,
|