@agentshouse/mdruntime 0.1.0-c47fe48697eec → 0.1.0-c4c5934c45f21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (382) hide show
  1. package/README.md +19 -16
  2. package/dist/acceptance.d.ts +3 -0
  3. package/dist/acceptance.d.ts.map +1 -0
  4. package/dist/acceptance.js +308 -0
  5. package/dist/act-lanes.d.ts +33 -0
  6. package/dist/act-lanes.d.ts.map +1 -0
  7. package/dist/act-lanes.js +177 -0
  8. package/dist/actions.d.ts +20 -0
  9. package/dist/actions.d.ts.map +1 -0
  10. package/dist/actions.js +251 -0
  11. package/dist/adapter.d.ts +174 -116
  12. package/dist/adapter.d.ts.map +1 -1
  13. package/dist/attached-model.d.ts +7 -10
  14. package/dist/attached-model.d.ts.map +1 -1
  15. package/dist/attached-model.js +40 -41
  16. package/dist/binary.d.ts +0 -5
  17. package/dist/binary.d.ts.map +1 -1
  18. package/dist/binary.js +1 -1
  19. package/dist/bootstrap.d.ts +31 -11
  20. package/dist/bootstrap.d.ts.map +1 -1
  21. package/dist/bootstrap.js +309 -109
  22. package/dist/cell.d.ts +6 -0
  23. package/dist/cell.d.ts.map +1 -0
  24. package/dist/cell.js +9 -0
  25. package/dist/chain.d.ts +12 -0
  26. package/dist/chain.d.ts.map +1 -0
  27. package/dist/chain.js +64 -0
  28. package/dist/change-set.d.ts +13 -14
  29. package/dist/change-set.d.ts.map +1 -1
  30. package/dist/change-set.js +17 -63
  31. package/dist/change.d.ts +32 -1
  32. package/dist/change.d.ts.map +1 -1
  33. package/dist/change.js +14 -3
  34. package/dist/chat-types.d.ts +5 -0
  35. package/dist/chat-types.d.ts.map +1 -0
  36. package/dist/chat-types.js +13 -0
  37. package/dist/client.d.ts +45 -23
  38. package/dist/client.d.ts.map +1 -1
  39. package/dist/client.js +129 -25
  40. package/dist/collection.d.ts +31 -9
  41. package/dist/collection.d.ts.map +1 -1
  42. package/dist/collection.js +49 -80
  43. package/dist/compile.d.ts +16 -0
  44. package/dist/compile.d.ts.map +1 -0
  45. package/dist/compile.js +711 -0
  46. package/dist/connection.d.ts +7 -118
  47. package/dist/connection.d.ts.map +1 -1
  48. package/dist/connection.js +105 -2716
  49. package/dist/context.d.ts +2 -0
  50. package/dist/context.d.ts.map +1 -0
  51. package/dist/{chat/context.js → context.js} +1 -4
  52. package/dist/conversation-live.d.ts +136 -0
  53. package/dist/conversation-live.d.ts.map +1 -0
  54. package/dist/conversation-live.js +249 -0
  55. package/dist/conversation-row.d.ts +33 -0
  56. package/dist/conversation-row.d.ts.map +1 -0
  57. package/dist/conversation-row.js +53 -0
  58. package/dist/conversation.d.ts +71 -48
  59. package/dist/conversation.d.ts.map +1 -1
  60. package/dist/conversation.js +1039 -679
  61. package/dist/declaration.d.ts +10 -0
  62. package/dist/declaration.d.ts.map +1 -0
  63. package/dist/declaration.js +24 -0
  64. package/dist/digest.d.ts +7 -0
  65. package/dist/digest.d.ts.map +1 -0
  66. package/dist/digest.js +113 -0
  67. package/dist/discovery.d.ts +10 -0
  68. package/dist/discovery.d.ts.map +1 -0
  69. package/dist/discovery.js +148 -0
  70. package/dist/durability.d.ts +19 -1
  71. package/dist/durability.d.ts.map +1 -1
  72. package/dist/durability.js +5 -0
  73. package/dist/entry.d.ts +7 -4
  74. package/dist/entry.d.ts.map +1 -1
  75. package/dist/entry.js +33 -28
  76. package/dist/expectation.d.ts +4 -2
  77. package/dist/expectation.d.ts.map +1 -1
  78. package/dist/expectation.js +33 -11
  79. package/dist/failure.d.ts +1 -0
  80. package/dist/failure.d.ts.map +1 -1
  81. package/dist/failure.js +3 -0
  82. package/dist/figures.d.ts +49 -0
  83. package/dist/figures.d.ts.map +1 -0
  84. package/dist/figures.js +197 -0
  85. package/dist/file.d.ts +2 -19
  86. package/dist/file.d.ts.map +1 -1
  87. package/dist/file.js +7 -122
  88. package/dist/holdings.d.ts +29 -0
  89. package/dist/holdings.d.ts.map +1 -0
  90. package/dist/holdings.js +95 -0
  91. package/dist/host.d.ts +26 -4
  92. package/dist/host.d.ts.map +1 -1
  93. package/dist/host.js +161 -25
  94. package/dist/identity.d.ts +0 -1
  95. package/dist/identity.d.ts.map +1 -1
  96. package/dist/identity.js +0 -3
  97. package/dist/index.d.ts +37 -13
  98. package/dist/index.d.ts.map +1 -1
  99. package/dist/index.js +15 -2
  100. package/dist/install.d.ts +54 -0
  101. package/dist/install.d.ts.map +1 -0
  102. package/dist/install.js +538 -0
  103. package/dist/lifecycle.d.ts +7 -0
  104. package/dist/lifecycle.d.ts.map +1 -0
  105. package/dist/lifecycle.js +272 -0
  106. package/dist/listing.d.ts +48 -0
  107. package/dist/listing.d.ts.map +1 -0
  108. package/dist/listing.js +139 -0
  109. package/dist/live.d.ts +23 -0
  110. package/dist/live.d.ts.map +1 -0
  111. package/dist/live.js +165 -0
  112. package/dist/locks.d.ts +7 -0
  113. package/dist/locks.d.ts.map +1 -0
  114. package/dist/locks.js +33 -0
  115. package/dist/log.d.ts +1 -0
  116. package/dist/log.d.ts.map +1 -1
  117. package/dist/lost.d.ts +5 -0
  118. package/dist/lost.d.ts.map +1 -0
  119. package/dist/lost.js +50 -0
  120. package/dist/media.d.ts +8 -0
  121. package/dist/media.d.ts.map +1 -0
  122. package/dist/media.js +218 -0
  123. package/dist/memory.d.ts +22 -7
  124. package/dist/memory.d.ts.map +1 -1
  125. package/dist/memory.js +278 -110
  126. package/dist/messages.d.ts +49 -0
  127. package/dist/messages.d.ts.map +1 -0
  128. package/dist/messages.js +150 -0
  129. package/dist/model.d.ts +11 -12
  130. package/dist/model.d.ts.map +1 -1
  131. package/dist/model.js +7 -15
  132. package/dist/models.d.ts +10 -0
  133. package/dist/models.d.ts.map +1 -0
  134. package/dist/models.js +156 -0
  135. package/dist/name.d.ts +4 -0
  136. package/dist/name.d.ts.map +1 -0
  137. package/dist/name.js +122 -0
  138. package/dist/observation.d.ts +22 -4
  139. package/dist/observation.d.ts.map +1 -1
  140. package/dist/observation.js +127 -26
  141. package/dist/opened.d.ts +22 -0
  142. package/dist/opened.d.ts.map +1 -0
  143. package/dist/opened.js +107 -0
  144. package/dist/opening.d.ts +4 -0
  145. package/dist/opening.d.ts.map +1 -0
  146. package/dist/opening.js +59 -0
  147. package/dist/outcome.d.ts +49 -8
  148. package/dist/outcome.d.ts.map +1 -1
  149. package/dist/outcome.js +42 -0
  150. package/dist/overlay.d.ts +5 -4
  151. package/dist/overlay.d.ts.map +1 -1
  152. package/dist/overlay.js +131 -199
  153. package/dist/page-metadata.d.ts +8 -0
  154. package/dist/page-metadata.d.ts.map +1 -0
  155. package/dist/page-metadata.js +19 -0
  156. package/dist/parts.d.ts +11 -0
  157. package/dist/parts.d.ts.map +1 -0
  158. package/dist/parts.js +21 -0
  159. package/dist/paths.d.ts +2 -0
  160. package/dist/paths.d.ts.map +1 -1
  161. package/dist/paths.js +26 -0
  162. package/dist/preparation.d.ts +20 -0
  163. package/dist/preparation.d.ts.map +1 -0
  164. package/dist/preparation.js +233 -0
  165. package/dist/presence.d.ts +52 -0
  166. package/dist/presence.d.ts.map +1 -0
  167. package/dist/presence.js +220 -0
  168. package/dist/queries.d.ts +16 -0
  169. package/dist/queries.d.ts.map +1 -0
  170. package/dist/queries.js +270 -0
  171. package/dist/query.d.ts +49 -183
  172. package/dist/query.d.ts.map +1 -1
  173. package/dist/query.js +3 -464
  174. package/dist/{chat/questions.d.ts → questions.d.ts} +5 -2
  175. package/dist/questions.d.ts.map +1 -0
  176. package/dist/{chat/questions.js → questions.js} +13 -2
  177. package/dist/queue.d.ts +40 -0
  178. package/dist/queue.d.ts.map +1 -0
  179. package/dist/queue.js +455 -0
  180. package/dist/reach.d.ts +21 -7
  181. package/dist/reach.d.ts.map +1 -1
  182. package/dist/reach.js +314 -95
  183. package/dist/react.d.ts +27 -6
  184. package/dist/react.d.ts.map +1 -1
  185. package/dist/react.js +22 -18
  186. package/dist/{chat/read.d.ts → read.d.ts} +2 -0
  187. package/dist/read.d.ts.map +1 -0
  188. package/dist/{chat/read.js → read.js} +4 -0
  189. package/dist/readiness.d.ts +49 -0
  190. package/dist/readiness.d.ts.map +1 -0
  191. package/dist/readiness.js +27 -0
  192. package/dist/reads.d.ts +37 -0
  193. package/dist/reads.d.ts.map +1 -0
  194. package/dist/reads.js +174 -0
  195. package/dist/recovery.d.ts +3 -2
  196. package/dist/recovery.d.ts.map +1 -1
  197. package/dist/recovery.js +43 -8
  198. package/dist/refresh.d.ts +17 -14
  199. package/dist/refresh.d.ts.map +1 -1
  200. package/dist/refresh.js +145 -53
  201. package/dist/refusal.d.ts +5 -0
  202. package/dist/refusal.d.ts.map +1 -0
  203. package/dist/refusal.js +57 -0
  204. package/dist/replica.d.ts +50 -33
  205. package/dist/replica.d.ts.map +1 -1
  206. package/dist/replica.js +339 -162
  207. package/dist/room-draft.d.ts +39 -10
  208. package/dist/room-draft.d.ts.map +1 -1
  209. package/dist/room-draft.js +186 -115
  210. package/dist/room-drafts.d.ts +24 -0
  211. package/dist/room-drafts.d.ts.map +1 -0
  212. package/dist/room-drafts.js +217 -0
  213. package/dist/rows.d.ts +30 -37
  214. package/dist/rows.d.ts.map +1 -1
  215. package/dist/rows.js +60 -128
  216. package/dist/runtime.d.ts +34 -0
  217. package/dist/runtime.d.ts.map +1 -0
  218. package/dist/runtime.js +1 -0
  219. package/dist/save.d.ts +42 -43
  220. package/dist/save.d.ts.map +1 -1
  221. package/dist/save.js +723 -233
  222. package/dist/saves.d.ts +32 -0
  223. package/dist/saves.d.ts.map +1 -0
  224. package/dist/saves.js +413 -0
  225. package/dist/search.d.ts +15 -55
  226. package/dist/search.d.ts.map +1 -1
  227. package/dist/search.js +10 -121
  228. package/dist/seed.d.ts +25 -0
  229. package/dist/seed.d.ts.map +1 -0
  230. package/dist/seed.js +145 -0
  231. package/dist/shared.d.ts +10 -0
  232. package/dist/shared.d.ts.map +1 -0
  233. package/dist/shared.js +339 -0
  234. package/dist/shown.d.ts +32 -0
  235. package/dist/shown.d.ts.map +1 -0
  236. package/dist/shown.js +290 -0
  237. package/dist/socket/admission.d.ts +7 -0
  238. package/dist/socket/admission.d.ts.map +1 -0
  239. package/dist/socket/admission.js +39 -0
  240. package/dist/socket/answers.d.ts +6 -0
  241. package/dist/socket/answers.d.ts.map +1 -0
  242. package/dist/socket/answers.js +20 -0
  243. package/dist/socket/lanes.d.ts +20 -0
  244. package/dist/socket/lanes.d.ts.map +1 -0
  245. package/dist/socket/lanes.js +77 -0
  246. package/dist/socket/reads.d.ts +10 -0
  247. package/dist/socket/reads.d.ts.map +1 -0
  248. package/dist/socket/reads.js +31 -0
  249. package/dist/socket/session.d.ts +38 -0
  250. package/dist/socket/session.d.ts.map +1 -0
  251. package/dist/socket/session.js +23 -0
  252. package/dist/socket.d.ts +67 -0
  253. package/dist/socket.d.ts.map +1 -0
  254. package/dist/socket.js +170 -0
  255. package/dist/source.d.ts +61 -0
  256. package/dist/source.d.ts.map +1 -0
  257. package/dist/source.js +82 -0
  258. package/dist/status.d.ts +5 -2
  259. package/dist/status.d.ts.map +1 -1
  260. package/dist/status.js +3 -7
  261. package/dist/store/installs.d.ts +30 -0
  262. package/dist/store/installs.d.ts.map +1 -0
  263. package/dist/store/installs.js +34 -0
  264. package/dist/store/readiness.d.ts +10 -0
  265. package/dist/store/readiness.d.ts.map +1 -0
  266. package/dist/store/readiness.js +52 -0
  267. package/dist/store/records.d.ts +212 -0
  268. package/dist/store/records.d.ts.map +1 -0
  269. package/dist/store/records.js +430 -0
  270. package/dist/store/room-held.d.ts +8 -0
  271. package/dist/store/room-held.d.ts.map +1 -0
  272. package/dist/store/room-held.js +17 -0
  273. package/dist/store/space.d.ts +11 -0
  274. package/dist/store/space.d.ts.map +1 -0
  275. package/dist/store/space.js +41 -0
  276. package/dist/store/watchers.d.ts +17 -0
  277. package/dist/store/watchers.d.ts.map +1 -0
  278. package/dist/store/watchers.js +56 -0
  279. package/dist/store/writes.d.ts +24 -0
  280. package/dist/store/writes.d.ts.map +1 -0
  281. package/dist/store/writes.js +125 -0
  282. package/dist/store.d.ts +109 -135
  283. package/dist/store.d.ts.map +1 -1
  284. package/dist/store.js +153 -617
  285. package/dist/stored.d.ts +156 -0
  286. package/dist/stored.d.ts.map +1 -0
  287. package/dist/stored.js +649 -0
  288. package/dist/surface.d.ts +88 -0
  289. package/dist/surface.d.ts.map +1 -0
  290. package/dist/surface.js +223 -0
  291. package/dist/sync.d.ts +19 -0
  292. package/dist/sync.d.ts.map +1 -0
  293. package/dist/sync.js +521 -0
  294. package/dist/tables.d.ts +412 -0
  295. package/dist/tables.d.ts.map +1 -0
  296. package/dist/tables.js +737 -0
  297. package/dist/tallies.d.ts +18 -0
  298. package/dist/tallies.d.ts.map +1 -0
  299. package/dist/tallies.js +129 -0
  300. package/dist/transfer.d.ts +0 -5
  301. package/dist/transfer.d.ts.map +1 -1
  302. package/dist/turn.d.ts +9 -0
  303. package/dist/turn.d.ts.map +1 -0
  304. package/dist/turn.js +75 -0
  305. package/dist/validation.d.ts +29 -0
  306. package/dist/validation.d.ts.map +1 -0
  307. package/dist/validation.js +104 -0
  308. package/dist/windows.d.ts +11 -0
  309. package/dist/windows.d.ts.map +1 -0
  310. package/dist/windows.js +16 -0
  311. package/dist/wire.d.ts +220 -36
  312. package/dist/wire.d.ts.map +1 -1
  313. package/dist/wire.js +73 -33
  314. package/package.json +19 -19
  315. package/AGENTS.md +0 -299
  316. package/dist/attempt.d.ts +0 -16
  317. package/dist/attempt.d.ts.map +0 -1
  318. package/dist/attempt.js +0 -70
  319. package/dist/chat/acts.d.ts +0 -33
  320. package/dist/chat/acts.d.ts.map +0 -1
  321. package/dist/chat/acts.js +0 -36
  322. package/dist/chat/context.d.ts +0 -3
  323. package/dist/chat/context.d.ts.map +0 -1
  324. package/dist/chat/input.d.ts +0 -9
  325. package/dist/chat/input.d.ts.map +0 -1
  326. package/dist/chat/input.js +0 -99
  327. package/dist/chat/kit.d.ts +0 -60
  328. package/dist/chat/kit.d.ts.map +0 -1
  329. package/dist/chat/kit.js +0 -123
  330. package/dist/chat/lasting.d.ts +0 -6
  331. package/dist/chat/lasting.d.ts.map +0 -1
  332. package/dist/chat/lasting.js +0 -19
  333. package/dist/chat/list.d.ts +0 -26
  334. package/dist/chat/list.d.ts.map +0 -1
  335. package/dist/chat/list.js +0 -62
  336. package/dist/chat/markdown.d.ts +0 -20
  337. package/dist/chat/markdown.d.ts.map +0 -1
  338. package/dist/chat/markdown.js +0 -188
  339. package/dist/chat/message.d.ts +0 -6
  340. package/dist/chat/message.d.ts.map +0 -1
  341. package/dist/chat/message.js +0 -192
  342. package/dist/chat/messages.d.ts +0 -21
  343. package/dist/chat/messages.d.ts.map +0 -1
  344. package/dist/chat/messages.js +0 -151
  345. package/dist/chat/name.d.ts +0 -6
  346. package/dist/chat/name.d.ts.map +0 -1
  347. package/dist/chat/name.js +0 -37
  348. package/dist/chat/opened.d.ts +0 -11
  349. package/dist/chat/opened.d.ts.map +0 -1
  350. package/dist/chat/opened.js +0 -17
  351. package/dist/chat/overlay.d.ts +0 -31
  352. package/dist/chat/overlay.d.ts.map +0 -1
  353. package/dist/chat/overlay.js +0 -97
  354. package/dist/chat/parts.d.ts +0 -57
  355. package/dist/chat/parts.d.ts.map +0 -1
  356. package/dist/chat/parts.js +0 -119
  357. package/dist/chat/process.d.ts +0 -20
  358. package/dist/chat/process.d.ts.map +0 -1
  359. package/dist/chat/process.js +0 -32
  360. package/dist/chat/provider.d.ts +0 -63
  361. package/dist/chat/provider.d.ts.map +0 -1
  362. package/dist/chat/provider.js +0 -620
  363. package/dist/chat/question.d.ts +0 -9
  364. package/dist/chat/question.d.ts.map +0 -1
  365. package/dist/chat/question.js +0 -80
  366. package/dist/chat/questions.d.ts.map +0 -1
  367. package/dist/chat/read.d.ts.map +0 -1
  368. package/dist/chat/ready.d.ts +0 -33
  369. package/dist/chat/ready.d.ts.map +0 -1
  370. package/dist/chat/ready.js +0 -91
  371. package/dist/chat/style.d.ts +0 -4
  372. package/dist/chat/style.d.ts.map +0 -1
  373. package/dist/chat/style.js +0 -302
  374. package/dist/chat.d.ts +0 -14
  375. package/dist/chat.d.ts.map +0 -1
  376. package/dist/chat.js +0 -8
  377. package/dist/fence.d.ts +0 -6
  378. package/dist/fence.d.ts.map +0 -1
  379. package/dist/fence.js +0 -10
  380. package/dist/read-side.d.ts +0 -18
  381. package/dist/read-side.d.ts.map +0 -1
  382. package/dist/read-side.js +0 -440
@@ -1,2731 +1,120 @@
1
- import { attachedModel } from './attached-model.js';
2
- import { cached, modelTypes, NO_MODEL, sameModel, } from './model.js';
3
- import { observing } from './observation.js';
4
- import { filterOf, identityOf, planOf, } from './query.js';
5
- import { createReadSide } from './read-side.js';
6
- import { markdownPath, roomOfKey } from './rows.js';
7
- import { createSearchIndex, searchPlanOf, } from './search.js';
8
- import { bootstrapRoom } from './bootstrap.js';
9
- import { changeSet, mergeChangeSets } from './change-set.js';
10
- import { createConversationStore, } from './conversation.js';
11
- import { queuedFile } from './change.js';
12
- import { validRoot } from './collection.js';
13
- import { runtimeError } from './failure.js';
1
+ import { submitLater } from './acceptance.js';
2
+ import { invokeAction, called, readConversationHistory, resendLater } from './actions.js';
3
+ import { builtInModel, roomTypesOf } from './attached-model.js';
4
+ import { createLiveConversations } from './conversation-live.js';
5
+ import { writeRule } from './declaration.js';
6
+ import { refusedForSpace } from './durability.js';
7
+ import { uncaught } from './failure.js';
8
+ import { createFigures } from './figures.js';
9
+ import { scheduleCurrency, spaceFreed, start } from './lifecycle.js';
10
+ import { createLiveQueries } from './live.js';
14
11
  import { createLog } from './log.js';
15
- import { binaryRecord } from './binary.js';
16
- import { absentBinary, binaryAnswer, calledResult, failure, historyAnswer, undeclared, UNCERTAIN, } from './outcome.js';
12
+ import { open } from './opening.js';
13
+ import { deliverOwedReadiness, filled, prepare } from './preparation.js';
14
+ import { createPresence } from './presence.js';
15
+ import { answeredPlan, figuresCover, roomTallies } from './queries.js';
16
+ import { readAnswers } from './reads.js';
17
17
  import { createRecovery } from './recovery.js';
18
- import { refreshRoom } from './refresh.js';
19
- import { buildBatch, joined, limitedIn, requeued } from './save.js';
20
- import { applyReturned, compositionOf, confirmedOf, landed, readReclassified, replicaOf, sameMembership, withdrawals, } from './replica.js';
21
- import { binaryBase, changedParts, changesOf, held, heldFile, joinedDraft, readParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.js';
22
- import { same, saving, STARTING, transferring, } from './status.js';
23
- import { detectStorageLoss, nextGeneration } from './durability.js';
24
- import { FencedMap } from './fence.js';
25
- import { identityTime, roomDraftRevision } from './identity.js';
26
- import { beneath, normalize } from './paths.js';
27
- import { openRuntimeStore, } from './store.js';
28
- import { unconfirmed } from './transfer.js';
29
- import { governs, holds, narrowed, planReach, } from './reach.js';
30
- function within(root, path) {
31
- return root === '' || beneath(root, path);
32
- }
33
- function declaredSelection(room) {
34
- const selection = room.typedSelection;
35
- if (selection === undefined)
36
- return true;
37
- if (!Array.isArray(selection.roots) || selection.roots.length === 0)
38
- return false;
39
- return selection.roots.every((root, index) => validRoot(root) &&
40
- root !== '' &&
41
- selection.roots.every((other, at) => at === index || !within(other, root)));
42
- }
43
- const OPENING_LANE = 'opening';
44
- const CONVERSATION_LANE = 'conversations';
45
- const ROOM_READS = 256;
18
+ import { publishChangeSet, show } from './shown.js';
19
+ import { createSocket } from './socket.js';
20
+ import { createStore } from './store.js';
21
+ import { composedRuntime } from './surface.js';
46
22
  const ROOM_ATTEMPTS = 16;
47
- function abandonedOn(signal) {
48
- return new Promise((resolve) => {
49
- if (signal.aborted)
50
- resolve(null);
51
- else
52
- signal.addEventListener('abort', () => resolve(null), { once: true });
53
- });
54
- }
55
- function roomLane(locator) {
56
- return `room ${locator}`;
57
- }
58
23
  export function composeRuntime(options) {
59
- const localSaves = options.adapter.localSaves === true;
60
- let authorization = options.authorization;
61
- let opening;
62
- let store;
63
- const fences = new Map();
64
- const isFenced = (locator) => fences.has(locator);
65
- let fencings = 0;
66
- const lastFenced = new Map();
67
- const fencedSince = (locator, since) => fences.has(locator) || (lastFenced.get(locator) ?? 0) > since;
68
- let discoveries = 0;
69
- const replicas = new FencedMap(isFenced);
70
- const queuesWithoutReplica = new FencedMap(isFenced);
71
- const pendings = new Map();
72
- const roomDrafts = new FencedMap(isFenced);
73
- const presentations = new Map();
74
- let limits = [];
75
- let capabilities = [];
76
- const rooms = new FencedMap(isFenced);
77
- const counted = new Map();
78
- const unreadable = new Set();
79
- const isModelFenced = (key) => isFenced(key.slice(key.indexOf(' ') + 1));
80
- const models = new FencedMap(isModelFenced);
81
- const liveModels = new FencedMap(isModelFenced);
82
- const invalidModels = new Set();
83
- const discovered = new Map();
84
- let roomsListed = false;
85
- const scopedRefusals = new Map();
86
- const sourceRefusals = new Map();
87
- const declarationRefusals = new Set();
88
- function modelKey(locator, attached) {
89
- return `${attached} ${locator}`;
90
- }
91
- function modelOf(locator, attached = 'collection') {
92
- return models.get(modelKey(locator, attached)) ?? NO_MODEL;
93
- }
94
- function savedModel(locator, attached) {
95
- return invalidModels.has(modelKey(locator, attached))
96
- ? { status: 'unavailable', reason: 'revoked' }
97
- : modelOf(locator, attached);
98
- }
99
- function compositionFor(record) {
100
- return compositionOf({
101
- ...record,
102
- model: savedModel(record.locator, 'collection'),
103
- selectionModel: savedModel(record.locator, 'typed-selection'),
104
- });
105
- }
106
- let refusal = null;
107
- let storageLoss = null;
108
- let status = STARTING;
109
- let shown = STARTING;
110
- let discoveryPaused = false;
111
- let closed = false;
112
- let stopping = false;
113
- let withdrawStream;
114
- const announced = new Map();
115
- let underway = null;
116
- let streamed = null;
117
- let handed = false;
118
- const recovery = (options.recovery ?? createRecovery()).scope(ROOM_ATTEMPTS);
119
- const repairing = new Set();
120
- const repairable = new Map();
121
- let outcomeRetention = null;
122
- const answering = new Map();
123
- let complete = false;
124
- let recorded = false;
125
- const stale = new Set();
126
- let generation = 0;
127
- let discovering = null;
128
- let opened = null;
129
- const owed = new Set();
130
- const lanes = new Map();
131
- let roomReads = { generation, free: ROOM_READS, waiting: [] };
132
- const working = new Set();
133
- let mutations = Promise.resolve();
134
- const roomListeners = new Set();
135
- const refusalListeners = new Set();
136
- const storageLossListeners = new Set();
137
- const statusListeners = new Set();
138
- const queueSubscriptions = new Set();
139
- const roomDraftListeners = new Set();
140
- const presentationListeners = new Set();
141
- const readSide = createReadSide();
142
- let withdrawConversations;
143
- let currencyQueued = null;
144
- let socketOpen = false;
145
- let serviceMode = 'open';
146
- let haltedRefusal = false;
147
- let openSignals = 0;
148
- const serviceModeListeners = new Set();
149
- let member = null;
150
- const memberListeners = new Set();
151
- const materialized = new Set();
152
- let everyRoom = false;
153
- const transfers = new FencedMap(isFenced);
154
- const conversations = createConversationStore({
155
- agents: declaredAgents,
156
- documents: (locator) => rowsQuery(planOf({ rooms: [locator], select: 'all' }, roomFacts())),
157
- call: (name, input) => invokeAction(name, input),
158
- durably,
159
- stream: () => options.adapter.conversations,
160
- publish: publishChangeSet,
161
- online: () => !status.providerUnreachable && refusal === null,
162
- closed: () => closed,
163
- unanswered: resendLater,
164
- expired: (operation) => pastHorizon(operation),
165
- });
166
- const searchIndex = createSearchIndex({
167
- documents: () => readSide.documents(),
168
- document: (room, path) => readSide.document(room, path),
169
- messages: () => conversations.messages(),
170
- message: (conversation, identity) => conversations.message(conversation, identity),
171
- });
24
+ const { adapter, shell } = options;
25
+ const roomTypes = roomTypesOf(adapter.roomTypes, adapter.nameableRoomTypes);
26
+ const builtIn = builtInModel(roomTypes);
27
+ const typedPaths = adapter.typedPaths ?? [];
172
28
  const journal = createLog();
173
- let notifyReady = () => { };
174
- const ready = new Promise((resolve) => {
175
- notifyReady = resolve;
176
- });
177
- function rememberRoomDraft(record) {
178
- const room = roomDrafts.get(record.locator) ?? new Map();
179
- room.set(record.path, record);
180
- roomDrafts.set(record.locator, room);
181
- }
182
- function forgetRoomDraft(locator, path) {
183
- const room = roomDrafts.get(locator);
184
- if (room === undefined)
185
- return;
186
- room.delete(path);
187
- if (room.size === 0)
188
- roomDrafts.delete(locator);
189
- }
190
- function roomDraftOf(record) {
191
- return structuredClone({
192
- room: record.locator,
193
- path: record.path,
194
- revision: record.revision,
195
- parts: record.parts,
196
- changedUnderneath: underneath(record.parts, record.path, replicas.get(record.locator)?.visible),
197
- returned: record.returned,
198
- });
199
- }
200
- function snapshotRoomDrafts() {
201
- const records = [...roomDrafts.values()].flatMap((room) => [...room.values()]);
202
- records.sort((left, right) => {
203
- if (left.locator !== right.locator)
204
- return left.locator < right.locator ? -1 : 1;
205
- if (left.path !== right.path)
206
- return left.path < right.path ? -1 : 1;
207
- return 0;
208
- });
209
- return records.map(roomDraftOf);
210
- }
211
- function publishRoomDrafts(waitingOnly) {
212
- if (closed)
213
- return;
214
- const value = snapshotRoomDrafts();
215
- for (const listener of roomDraftListeners) {
216
- if (waitingOnly && listener.ready)
217
- continue;
218
- listener.ready = true;
219
- listener.notify(value);
220
- }
221
- }
222
- function presentationOf(app) {
223
- const value = presentations.get(app);
224
- return value === undefined ? null : structuredClone(value);
225
- }
226
- function emitPresentation(app) {
227
- if (closed)
228
- return;
229
- for (const listener of presentationListeners) {
230
- if (listener.app === app && listener.ready)
231
- listener.notify(presentationOf(app));
232
- }
233
- }
234
- function pending() {
235
- return (!localSaves &&
236
- (queuesWithoutReplica.size > 0 ||
237
- [...replicas.values()].some((replica) => replica.queue.length > 0)));
238
- }
239
- function attention() {
240
- const attentionRequired = [];
241
- for (const record of [...roomDrafts.values()].flatMap((room) => [...room.values()])) {
242
- if (record.returned === null)
243
- continue;
244
- attentionRequired.push({
245
- room: record.locator,
246
- path: record.path,
247
- returned: structuredClone(record.returned),
248
- });
249
- }
250
- attentionRequired.sort((left, right) => {
251
- if (left.room !== right.room)
252
- return left.room < right.room ? -1 : 1;
253
- if (left.path !== right.path)
254
- return left.path < right.path ? -1 : 1;
255
- return 0;
256
- });
257
- let reset = null;
258
- for (const { submission } of pendings.values()) {
259
- if (submission.state !== 'reset')
260
- continue;
261
- if (reset === null || submission.reset < reset)
262
- reset = submission.reset;
263
- }
264
- return { attentionRequired, reset };
265
- }
266
- function documentsIn(locator) {
267
- const replica = replicas.get(locator);
268
- if (replica === undefined)
269
- return 0;
270
- const roots = replica.confirmed.record.typedSelection?.roots ?? [];
271
- const paths = [
272
- ...Object.keys(replica.visible.documents).filter(markdownPath),
273
- ...Object.keys(replica.visible.binaries),
274
- ];
275
- return paths.filter((path) => !roots.some((root) => beneath(root, path))).length;
276
- }
277
- function listed() {
278
- return structuredClone([...rooms.values()].map((room) => {
279
- const documents = documentsIn(room.locator);
280
- counted.set(room.locator, documents);
281
- return { ...room, documents };
282
- }));
283
- }
284
- function roomFacts(reach = null) {
285
- const held = [...rooms.values()]
286
- .filter((room) => holds(reach, room.locator))
287
- .map((room) => {
288
- const governed = governs(reach, room);
289
- const attached = [
290
- ...(governed.collection ? [modelOf(room.locator)] : []),
291
- ...(governed.selection ? [modelOf(room.locator, 'typed-selection')] : []),
292
- ];
293
- return {
294
- locator: room.locator,
295
- available: attached.every((model) => model.status !== 'unavailable'),
296
- types: attached.flatMap((model) => model.status === 'unavailable' ? [] : Object.values(model.types)),
297
- };
298
- });
299
- return { listed: roomsListed, rooms: held };
300
- }
301
- function emitRooms() {
302
- const value = listed();
303
- for (const listener of roomListeners)
304
- listener(value);
305
- }
306
- function emitRefusal() {
307
- for (const listener of refusalListeners)
308
- listener(refusal);
309
- }
310
- function emitStorageLoss() {
311
- for (const listener of storageLossListeners)
312
- listener(storageLoss);
313
- }
314
- function emitMember() {
315
- for (const listener of memberListeners)
316
- listener(member);
317
- }
318
- function moveTo(next) {
319
- if (closed)
320
- return;
321
- status = next;
322
- show();
323
- }
324
- function show() {
325
- if (closed)
326
- return;
327
- const next = status.state === 'synced' && !conversations.current()
328
- ? { ...status, state: 'syncing' }
329
- : status;
330
- if (same(shown, next))
331
- return;
332
- shown = next;
333
- for (const listener of statusListeners)
334
- listener(shown);
335
- }
336
- function entryOf(batch) {
337
- if (localSaves)
338
- return Object.freeze({ batch, state: 'local' });
339
- const state = pendings.get(batch.id);
340
- if (state?.accepted !== undefined) {
341
- return Object.freeze({ batch, state: 'accepted', roomVersion: state.accepted });
342
- }
343
- return Object.freeze({ batch, ...(state?.submission ?? { state: 'waiting' }) });
344
- }
345
- function entriesOf(locator) {
346
- return (replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? []).map(entryOf);
347
- }
348
- function emitQueue(locator) {
349
- const entries = entriesOf(locator);
350
- for (const subscription of queueSubscriptions) {
351
- if (subscription.locator === locator)
352
- subscription.notify(entries);
353
- }
354
- }
355
- function applyChangeSet(set) {
356
- const held = everyRoom
357
- ? set
358
- : { ...set, documents: set.documents.filter(({ locator }) => materialized.has(locator)) };
359
- readSide.apply(held);
360
- searchIndex.changed(held);
361
- }
362
- function materialize(locators) {
363
- if (everyRoom)
364
- return;
365
- if (locators === null)
366
- everyRoom = true;
367
- const sets = [];
368
- for (const locator of locators ?? [...replicas.keys()]) {
369
- if (materialized.has(locator))
370
- continue;
371
- materialized.add(locator);
372
- const replica = replicas.get(locator);
373
- if (replica !== undefined)
374
- sets.push(changeSet(locator, null, replica));
375
- }
376
- if (sets.length === 0)
377
- return;
378
- const set = mergeChangeSets(sets);
379
- readSide.apply(set);
380
- searchIndex.changed(set);
381
- }
382
- function reachedRooms(plan) {
383
- if (plan.rooms !== null)
384
- return plan.rooms;
385
- if (plan.reach === null)
386
- return null;
387
- return [...plan.reach.rooms, ...plan.reach.documents.map(roomOfKey)];
388
- }
389
- function rowsQuery(plan) {
390
- materialize(reachedRooms(plan));
391
- return readSide.query(plan);
392
- }
393
- function publishChangeSet(set) {
394
- applyChangeSet(set);
395
- if (set.rooms.length > 0 ||
396
- [...new Set(set.documents.map(({ locator }) => locator))].some((locator) => rooms.has(locator) && counted.get(locator) !== documentsIn(locator)))
397
- emitRooms();
398
- for (const locator of set.queues)
399
- emitQueue(locator);
400
- if (set.drafts.length > 0 ||
401
- set.documents.some((change) => roomDrafts.get(change.locator)?.has(change.path) === true)) {
402
- publishRoomDrafts(false);
403
- }
404
- for (const app of set.presentations)
405
- emitPresentation(app);
406
- conversations.changed(set);
407
- }
408
- async function refuse(reason, provider = null) {
409
- discoveryPaused = true;
410
- try {
411
- if (reason === 'revoked-authorization') {
412
- await exclusive(async () => {
413
- const revoked = { status: 'unavailable', reason: 'revoked' };
414
- try {
415
- const local = await openLocal();
416
- await local.revokeModels([...replicas.values()].map((replica) => replica.confirmed.record));
417
- }
418
- catch {
419
- journal.record('model revocation persistence failed');
420
- }
421
- const keys = new Set(models.keys());
422
- for (const locator of rooms.keys()) {
423
- keys.add(modelKey(locator, 'collection'));
424
- keys.add(modelKey(locator, 'typed-selection'));
425
- }
426
- for (const key of keys) {
427
- invalidModels.add(key);
428
- models.set(key, revoked);
429
- liveModels.delete(key);
430
- }
431
- const changed = [];
432
- for (const [locator, room] of rooms) {
433
- const before = replicas.get(locator) ?? null;
434
- if (before !== null) {
435
- const record = {
436
- ...before.confirmed.record,
437
- model: revoked,
438
- selectionModel: revoked,
439
- };
440
- replicas.set(locator, replicaOf(confirmedOf(record, before.confirmed), before.queue, before));
441
- }
442
- rooms.set(locator, {
443
- ...room,
444
- model: modelTypes(revoked),
445
- typedSelection: room.typedSelection === null
446
- ? null
447
- : { ...room.typedSelection, model: modelTypes(revoked) },
448
- });
449
- changed.push(changeSet(locator, before, replicas.get(locator) ?? null, { room: true }));
450
- }
451
- publishChangeSet(mergeChangeSets(changed));
452
- });
453
- }
454
- }
455
- finally {
456
- refusal = {
457
- code: reason,
458
- retryable: false,
459
- reauthorizationOffered: reason === 'revoked-authorization',
460
- refusal: provider,
461
- };
462
- journal.record(`connection refused ${reason}`);
463
- emitRefusal();
464
- }
465
- }
466
- function list(room, synchronizationAvailable) {
467
- const selection = room.typedSelection ?? null;
468
- rooms.set(room.locator, {
469
- name: room.name,
470
- locator: room.locator,
471
- handle: room.handle,
472
- operations: room.operations,
473
- replica: room.replica,
474
- model: modelTypes(modelOf(room.locator)),
475
- typedSelection: selection === null
476
- ? null
477
- : {
478
- roots: selection.roots,
479
- model: modelTypes(modelOf(room.locator, 'typed-selection')),
480
- },
481
- providerOwnedPaths: room.providerOwnedPaths,
482
- roomVersion: replicas.get(room.locator)?.confirmed.record.roomVersion ?? null,
483
- synchronizationAvailable,
484
- refusal: scopedRefusals.get(room.locator) ?? sourceRefusals.get(room.locator) ?? null,
485
- });
486
- }
487
- async function applyDiscovery(found, started) {
488
- for (const room of found) {
489
- const fence = fences.get(room.locator);
490
- if (fence !== undefined && fence.erased && fence.at < started)
491
- fences.delete(room.locator);
492
- }
493
- const listed = found.filter((room) => !fences.has(room.locator));
494
- const listedLocators = new Set(listed.map((room) => room.locator));
495
- for (const locator of listedLocators)
496
- scopedRefusals.delete(locator);
497
- discovered.clear();
498
- for (const room of listed)
499
- discovered.set(room.locator, room);
500
- const unlisted = unlistedHeld(new Set(found.map((room) => room.locator)));
501
- if (options.adapter.exhaustiveDiscovery === true)
502
- await loseRooms(unlisted);
503
- else
504
- unlistedKept(unlisted);
505
- for (const room of listed) {
506
- const held = replicas.get(room.locator)?.confirmed.record;
507
- if (held !== undefined && held.replica.selection !== room.replica.selection) {
508
- list(held, false);
509
- continue;
510
- }
511
- list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
512
- }
513
- roomsListed = true;
514
- emitRooms();
515
- return listed;
516
- }
517
- function unlistedHeld(listed) {
518
- return [
519
- ...new Set([
520
- ...rooms.keys(),
521
- ...roomDrafts.keys(),
522
- ...transfers.keys(),
523
- ...queuesWithoutReplica.keys(),
524
- ]),
525
- ].filter((locator) => !listed.has(locator));
526
- }
527
- function unlistedKept(unlisted) {
528
- for (const locator of unlisted) {
529
- const held = replicas.get(locator)?.confirmed.record;
530
- if (held !== undefined)
531
- list(held, false);
532
- else
533
- rooms.delete(locator);
534
- }
535
- }
536
- function fence(locators) {
537
- const fresh = [...new Set(locators)].filter((locator) => !fences.has(locator));
538
- const removed = fresh.map((locator) => changeSet(locator, replicas.get(locator) ?? null, null, {
539
- room: true,
540
- queue: true,
541
- drafts: [...(roomDrafts.get(locator)?.keys() ?? [])],
542
- }));
543
- for (const locator of fresh) {
544
- fences.set(locator, { at: discoveries, erased: false });
545
- lastFenced.set(locator, ++fencings);
546
- for (const batch of replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? [])
547
- pendings.delete(batch.id);
548
- replicas.delete(locator);
549
- queuesWithoutReplica.delete(locator);
550
- rooms.delete(locator);
551
- roomDrafts.delete(locator);
552
- transfers.delete(locator);
553
- discovered.delete(locator);
554
- announced.delete(locator);
555
- unreadable.delete(locator);
556
- stale.delete(locator);
557
- repairable.delete(locator);
558
- scopedRefusals.delete(locator);
559
- sourceRefusals.delete(locator);
560
- declarationRefusals.delete(locator);
561
- for (const attached of ['collection', 'typed-selection']) {
562
- const key = modelKey(locator, attached);
563
- models.delete(key);
564
- liveModels.delete(key);
565
- invalidModels.delete(key);
566
- }
567
- journal.record(`room lost ${locator}`);
568
- }
569
- if (fresh.length === 0)
570
- return fresh;
571
- publishChangeSet(mergeChangeSets(removed));
572
- for (const locator of fresh)
573
- materialized.delete(locator);
574
- moveTo({ ...status, ...attention() });
575
- return fresh;
576
- }
577
- async function erased(local, locators) {
578
- await local.erase(locators);
579
- for (const locator of locators) {
580
- const held = fences.get(locator);
581
- if (held !== undefined)
582
- held.erased = true;
583
- }
584
- }
585
- async function loseRooms(locators) {
586
- const fresh = fence(locators);
587
- if (fresh.length > 0)
588
- await durably((local) => erased(local, fresh));
589
- }
590
- function restored(key, persisted) {
591
- const prior = models.get(key);
592
- if (prior !== undefined &&
593
- prior.status !== 'unavailable' &&
594
- (persisted.status === 'unavailable' || !sameModel(prior.snapshot, persisted.snapshot))) {
595
- invalidModels.add(key);
596
- }
597
- const model = persisted.status === 'unavailable' ||
598
- liveModels.get(key) === JSON.stringify(persisted.snapshot)
599
- ? persisted
600
- : cached(persisted);
601
- models.set(key, model);
602
- if (model.status === 'unavailable') {
603
- liveModels.delete(key);
604
- invalidModels.delete(key);
605
- }
606
- return model;
607
- }
608
- async function hydrate(opened) {
609
- const [records, queues, kept, presented, held, chatDrafts, lastCompleted, declared, named, known, staged,] = await Promise.all([
610
- opened.all(),
611
- opened.queues(),
612
- opened.roomDrafts(),
613
- opened.presentation(),
614
- opened.conversations(),
615
- opened.chatDrafts(),
616
- opened.lastCompleted(),
617
- opened.providerLimits(),
618
- opened.capabilities(),
619
- opened.member(),
620
- opened.transfers(),
621
- ]);
622
- transfers.clear();
623
- for (const record of staged)
624
- transfers.set(record.locator, record);
625
- limits = declared;
626
- capabilities = named;
627
- member = known;
628
- roomDrafts.clear();
629
- for (const record of kept)
630
- rememberRoomDraft(record);
631
- presentations.clear();
632
- for (const record of presented)
633
- presentations.set(record.app, record.value);
634
- conversations.hydrate(held, chatDrafts);
635
- const queuedBatches = new Map(queues.map((queue) => [queue.locator, queue.pending.map(({ batch }) => batch)]));
636
- pendings.clear();
637
- for (const queue of queues) {
638
- for (const { batch, state } of queue.pending)
639
- pendings.set(batch.id, state);
640
- }
641
- const previousReplicas = new Map(replicas);
642
- replicas.clear();
643
- queuesWithoutReplica.clear();
644
- const replicated = new Set(records.map((record) => record.locator));
645
- for (const [locator, queue] of queuedBatches) {
646
- if (!replicated.has(locator))
647
- queuesWithoutReplica.set(locator, queue);
648
- }
649
- for (const record of records) {
650
- const model = restored(modelKey(record.locator, 'collection'), record.model);
651
- const selectionModel = restored(modelKey(record.locator, 'typed-selection'), record.selectionModel);
652
- const prior = previousReplicas.get(record.locator);
653
- const confirmed = confirmedOf({ ...record, model, selectionModel }, prior?.confirmed);
654
- replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? [], prior));
655
- const existing = rooms.get(record.locator);
656
- if (existing === undefined)
657
- list(record, false);
658
- else {
659
- rooms.set(record.locator, {
660
- ...existing,
661
- roomVersion: record.roomVersion,
662
- operations: record.operations,
663
- replica: record.replica,
664
- model: modelTypes(model),
665
- typedSelection: record.typedSelection === null
666
- ? null
667
- : {
668
- roots: record.typedSelection.roots,
669
- model: modelTypes(selectionModel),
670
- },
671
- });
672
- }
673
- }
674
- return {
675
- lastCompleted,
676
- locators: new Set([...queuedBatches.keys(), ...replicas.keys()]),
677
- read: mergeChangeSets([...new Set([...previousReplicas.keys(), ...replicas.keys()])].map((locator) => changeSet(locator, previousReplicas.get(locator) ?? null, replicas.get(locator) ?? null))),
678
- };
679
- }
680
- async function readState(opened) {
681
- const { lastCompleted, locators, read } = await hydrate(opened);
682
- applyChangeSet(read);
683
- if (replicas.size > 0)
684
- emitRooms();
685
- if (member !== null)
686
- emitMember();
687
- for (const locator of locators)
688
- emitQueue(locator);
689
- publishRoomDrafts(false);
690
- return lastCompleted;
691
- }
692
- async function open() {
693
- if (closed)
694
- throw new Error('runtime closed');
695
- const opened = await openRuntimeStore(isFenced);
696
- store = opened;
697
- const interrupted = await opened.fences();
698
- for (const locator of interrupted) {
699
- fences.set(locator, { at: discoveries, erased: false });
700
- lastFenced.set(locator, ++fencings);
701
- }
702
- const kept = options.shell.generation;
703
- const storedGeneration = await opened.generation();
704
- const loss = detectStorageLoss(storedGeneration, kept);
705
- const generation = nextGeneration(storedGeneration, kept);
706
- if (generation !== storedGeneration)
707
- await opened.rememberGeneration(generation);
708
- if (generation !== kept)
709
- await options.shell.keepGeneration(generation);
710
- if (loss !== null) {
711
- storageLoss = loss;
712
- emitStorageLoss();
713
- }
714
- const lastCompleted = await readState(opened);
715
- if (interrupted.length > 0)
716
- await erased(opened, interrupted);
717
- moveTo({ ...status, lastCompleted, ...attention() });
718
- return opened;
719
- }
720
- function durably(work) {
721
- return exclusive(async () => {
722
- const local = await openLocal();
723
- return work(local);
724
- });
725
- }
726
- function openLocal() {
727
- opening ??= open().catch((error) => {
728
- opening = undefined;
729
- throw error;
730
- });
731
- return opening;
732
- }
733
- function exclusive(work) {
734
- const next = mutations.then(work, work);
735
- mutations = next.then(() => undefined, () => undefined);
736
- return next;
737
- }
738
- function withdrawable(batch) {
739
- const state = pendings.get(batch.id);
740
- return state !== undefined && state.submission.state !== 'submitted' && !state.lost;
741
- }
742
- async function settle(local, locator, before, confirmed, queue, settling = {}) {
743
- const previousQueue = before?.queue ?? queuesWithoutReplica.get(locator) ?? [];
744
- const withdrawn = withdrawals(confirmed, queue, withdrawable, localSaves);
745
- const kept = queue.filter((batch) => !withdrawn.includes(batch));
746
- const unqueued = withdrawn.map((batch) => ({
747
- batch,
748
- returned: localSaves || landed(batch, confirmed) ? null : returnedBy('withdrawn'),
749
- }));
750
- const returning = [
751
- ...[...unqueued].reverse(),
752
- ...(settling.leaving === undefined ? [] : [settling.leaving]),
753
- ];
754
- const written = new Map();
755
- for (const { batch, returned } of returning) {
756
- if (returned === null)
757
- continue;
758
- for (const saved of pendings.get(batch.id)?.drafts ?? []) {
759
- const existing = written.get(saved.path) ?? roomDrafts.get(locator)?.get(saved.path);
760
- written.set(saved.path, {
761
- locator,
762
- path: saved.path,
763
- revision: roomDraftRevision(),
764
- parts: returnedInto(existing?.parts, saved.parts),
765
- returned,
766
- });
767
- }
768
- }
769
- await local.keepAuthored({ locator, queue: kept, roomDrafts: [...written.values()] });
770
- for (const batch of previousQueue) {
771
- if (!kept.includes(batch))
772
- pendings.delete(batch.id);
773
- }
774
- for (const record of written.values())
775
- rememberRoomDraft(record);
776
- try {
777
- await local.write({
778
- next: confirmed.record,
779
- previous: before?.confirmed.record ?? null,
780
- ...(settling.stored === undefined ? {} : { stored: settling.stored }),
781
- });
782
- }
783
- catch (error) {
784
- const held = before === undefined ? null : replicaOf(before.confirmed, kept, before);
785
- if (held !== null)
786
- replicas.set(locator, held);
787
- else if (kept.length > 0)
788
- queuesWithoutReplica.set(locator, kept);
789
- else
790
- queuesWithoutReplica.delete(locator);
791
- publishChangeSet(changeSet(locator, before ?? null, held, {
792
- queue: kept.length !== previousQueue.length,
793
- drafts: [...written.keys()],
794
- }));
795
- moveTo({ ...status, ...attention() });
796
- throw error;
797
- }
798
- queuesWithoutReplica.delete(locator);
799
- for (const { batch, returned } of unqueued) {
800
- const outcome = localSaves ? 'dropped' : returned === null ? 'landed' : 'withdrawn';
801
- journal.record(`outcome ${locator} ${batch.id} ${outcome}`);
802
- }
803
- replicas.set(locator, replicaOf(confirmed, kept, before));
804
- return changeSet(locator, before ?? null, replicas.get(locator) ?? null, {
805
- room: settling.room,
806
- queue: kept.length !== previousQueue.length,
807
- drafts: [...written.keys()],
808
- });
809
- }
810
- function adoptModels(locator, record) {
811
- for (const [attached, model] of [
812
- ['collection', record.model],
813
- ['typed-selection', record.selectionModel],
814
- ]) {
815
- const key = modelKey(locator, attached);
816
- models.set(key, model);
817
- invalidModels.delete(key);
818
- if (model.status === 'current')
819
- liveModels.set(key, JSON.stringify(model.snapshot));
820
- else if (model.status === 'unavailable')
821
- liveModels.delete(key);
822
- }
823
- }
824
- function remodel(locator, answers, held) {
825
- const taken = (answer, previous, attached) => {
826
- if (answer === undefined)
827
- return previous;
828
- const { state, refused } = attachedModel(answer, previous);
829
- if (refused !== null) {
830
- const where = refused.location === undefined ? '' : ` ${refused.location}`;
831
- journal.record(`model invalid ${locator} ${attached} ${refused.identity} ${refused.rule}${where}`);
832
- }
833
- models.set(modelKey(locator, attached), state);
834
- return state;
835
- };
836
- return {
837
- collection: taken(answers?.collection, held.collection, 'collection'),
838
- selection: taken(answers?.selection, held.selection, 'typed-selection'),
839
- };
840
- }
841
- function publish(local, room, confirmed, landing, live) {
842
- const { base, stored } = landing;
843
- return exclusive(async () => {
844
- if (!live())
845
- return true;
846
- const prior = replicas.get(room.locator);
847
- if (base !== undefined &&
848
- (prior?.confirmed.record.roomVersion !== base.record.roomVersion ||
849
- prior.confirmed.record.revisions !== base.record.revisions)) {
850
- return false;
851
- }
852
- adoptModels(room.locator, confirmed.record);
853
- const queue = prior?.queue ?? queuesWithoutReplica.get(room.locator) ?? [];
854
- const roomVersion = confirmed.record.roomVersion;
855
- const accepted = queue.filter((batch) => {
856
- const accepted = pendings.get(batch.id)?.accepted;
857
- return (accepted !== undefined && options.adapter.reached(room.locator, roomVersion, accepted));
858
- });
859
- const set = await settle(local, room.locator, prior, confirmed, queue.filter((batch) => !accepted.includes(batch)), { room: true, ...(stored === undefined ? {} : { stored }) });
860
- if (stored !== undefined)
861
- transfers.delete(room.locator);
862
- for (const batch of accepted)
863
- pendings.delete(batch.id);
864
- stale.delete(room.locator);
865
- if (unreadable.delete(room.locator))
866
- scopedRefusals.delete(room.locator);
867
- sourceRefusals.delete(room.locator);
868
- declarationRefusals.delete(room.locator);
869
- list(room, true);
870
- publishChangeSet(set);
871
- moveTo({ ...status, ...attention() });
872
- options.adapter.roomStream?.published(room.locator, roomVersion);
873
- return true;
874
- });
875
- }
876
- async function saveRoomDrafts(locator, named, writtenBy) {
877
- const local = await openLocal();
878
- const replica = replicas.get(locator);
879
- const room = rooms.get(locator);
880
- if (replica === undefined || room === undefined) {
881
- throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
882
- }
883
- const saved = [];
884
- for (const { path, revision } of named) {
885
- const record = roomDrafts.get(locator)?.get(path);
886
- if (record === undefined || record.revision !== revision) {
887
- return { outcome: 'refused', code: 'stale', retryable: false, file: path };
888
- }
889
- if (!saved.some((draft) => draft.path === path))
890
- saved.push({ path, parts: record.parts });
891
- }
892
- const changed = saved.flatMap(({ path, parts }) => changedParts(path, underneath(parts, path, replica.visible)));
893
- if (changed.length > 0)
894
- return { outcome: 'refused', code: 'changed-underneath', retryable: false, parts: changed };
895
- const parts = saved.map(({ path, parts }) => changesOf(path, parts));
896
- const changes = parts.flatMap(({ changes }) => changes);
897
- const requeue = requeued(replica.queue, changes, replica.visible, withdrawable, (queue) => replicaOf(replica.confirmed, queue, replica).visible);
898
- if (requeue.kind === 'refused')
899
- return { outcome: 'refused', ...requeue.refusal };
900
- const foreign = [...requeue.withdrawn.keys()].some((origin) => {
901
- const writer = replica.queue.find((batch) => batch.id === origin)?.writtenBy;
902
- return writer?.app !== writtenBy?.app || writer?.release !== writtenBy?.release;
903
- });
904
- if (foreign) {
905
- return {
906
- outcome: 'refused',
907
- code: 'unknown-revision',
908
- retryable: false,
909
- file: [...requeue.queued].at(-1),
910
- };
911
- }
912
- const withdrawing = requeue.withdrawn.size > 0;
913
- const input = {
914
- local: localSaves,
915
- baseRoomVersion: replica.confirmed.record.roomVersion,
916
- composition: compositionFor(replica.confirmed.record),
917
- operations: room.operations,
918
- providerOwnedPaths: room.providerOwnedPaths,
919
- providerLimits: limits,
920
- handle: room.handle,
921
- visible: replica.visible,
922
- changes,
923
- bases: parts.flatMap(({ bases }) => bases),
924
- writtenBy,
925
- };
926
- const checked = withdrawing ? buildBatch({ ...input, queued: requeue.queued }) : null;
927
- if (checked?.kind === 'refused')
928
- return { outcome: 'refused', ...checked.refusal };
929
- const owners = [...requeue.owners].flatMap((origin) => {
930
- const batch = requeue.withdrawn.get(origin);
931
- return batch === undefined || batch === null ? [] : [{ origin, batch }];
932
- });
933
- if (owners.length > 1) {
934
- return {
935
- outcome: 'refused',
936
- code: 'unknown-revision',
937
- retryable: false,
938
- file: [...requeue.queued].at(-1),
939
- };
940
- }
941
- const built = !withdrawing
942
- ? buildBatch(input)
943
- : requeue.changes.length === 0
944
- ? null
945
- : buildBatch({
946
- ...input,
947
- visible: replicaOf(replica.confirmed, requeue.queue, replica).visible,
948
- changes: requeue.changes,
949
- });
950
- if (built?.kind === 'refused')
951
- return { outcome: 'refused', ...built.refusal };
952
- const [owner] = owners;
953
- const join = built === null || owner === undefined
954
- ? null
955
- : joined(requeue.queue, owner.batch, built.batch);
956
- if (join?.kind === 'refused')
957
- return { outcome: 'refused', ...join.refusal };
958
- const withdrawn = new Map(requeue.withdrawn);
959
- if (join !== null && owner !== undefined)
960
- withdrawn.set(owner.origin, join.batch);
961
- const drafted = new Map();
962
- for (const [origin, replaced] of withdrawn) {
963
- if (replaced === null)
964
- continue;
965
- const carried = withdrawnDrafts(pendings.get(origin)?.drafts ?? [], changes);
966
- drafted.set(replaced.id, replaced === join?.batch
967
- ? [
968
- ...carried.map((held) => joinedDraft(held, saved)),
969
- ...saved.filter((draft) => !carried.some((held) => held.path === draft.path)),
970
- ]
971
- : carried);
972
- }
973
- if (built !== null && join === null)
974
- drafted.set(built.batch.id, saved);
975
- const batches = join !== null ? join.queue : built === null ? requeue.queue : [...requeue.queue, built.batch];
976
- for (const replaced of withdrawn.values()) {
977
- if (replaced === null || !batches.includes(replaced))
978
- continue;
979
- const limited = limitedIn(batches, replaced, limits, (queue) => replicaOf(replica.confirmed, queue, replica).visible);
980
- if (limited !== null)
981
- return { outcome: 'refused', ...limited };
982
- }
983
- const consumed = saved.map(({ path }) => path);
984
- try {
985
- await local.keepAuthored({
986
- locator,
987
- queue: batches,
988
- saved: drafted,
989
- consumedRoomDrafts: consumed,
990
- });
991
- }
992
- catch {
993
- return { outcome: 'refused', code: 'durable-write', retryable: true };
994
- }
995
- if (fences.has(locator))
996
- throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
997
- for (const origin of withdrawn.keys())
998
- pendings.delete(origin);
999
- for (const [id, drafts] of drafted) {
1000
- pendings.set(id, { drafts, submission: { state: 'waiting' }, lost: false });
1001
- }
1002
- if (!localSaves)
1003
- recorded = false;
1004
- for (const path of consumed)
1005
- forgetRoomDraft(locator, path);
1006
- replicas.set(locator, replicaOf(replica.confirmed, batches, replica));
1007
- publishChangeSet(changeSet(locator, replica, replicas.get(locator) ?? null, {
1008
- queue: true,
1009
- drafts: consumed,
1010
- }));
1011
- moveTo({ ...(localSaves ? status : saving(status)), ...attention() });
1012
- submitLater(locator);
1013
- const identifier = join?.batch.id ??
1014
- built?.batch.id ??
1015
- [...requeue.withdrawn].map(([origin, replaced]) => replaced?.id ?? origin).at(-1);
1016
- return { outcome: 'saved', identifier };
1017
- }
1018
- async function mark(local, locator, identifier, submission, lost) {
1019
- const state = pendings.get(identifier);
1020
- if (!continuing() ||
1021
- state === undefined ||
1022
- (JSON.stringify(state.submission) === JSON.stringify(submission) && state.lost === lost)) {
1023
- return;
1024
- }
1025
- await local.submit(locator, identifier, submission, lost);
1026
- if (fences.has(locator))
1027
- return;
1028
- pendings.set(identifier, { ...state, submission, lost });
1029
- const replica = replicas.get(locator);
1030
- if (replica !== undefined)
1031
- publishChangeSet(changeSet(locator, replica, replica, { queue: true }));
1032
- moveTo({ ...status, ...attention() });
1033
- }
1034
- async function keepUpload(local, locator, identifier, upload) {
1035
- if (!continuing())
1036
- throw new Error('connection refused');
1037
- await local.keepUpload(locator, identifier, upload);
1038
- if (fences.has(locator))
1039
- throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
1040
- pendings.set(identifier, { ...pendings.get(identifier), upload });
1041
- if (!continuing())
1042
- throw new Error('connection refused');
1043
- }
1044
- async function readHistory(locator, path, query = {}) {
1045
- if (closed || refusal !== null)
1046
- return UNCERTAIN;
1047
- try {
1048
- await ensureAuthorization();
1049
- }
1050
- catch {
1051
- return UNCERTAIN;
1052
- }
1053
- if (closed || authorization === undefined || refusal !== null)
1054
- return UNCERTAIN;
1055
- const since = fencings;
1056
- const transfer = ['transfer', 'history', locator, path];
1057
- if (query.revision !== undefined)
1058
- transfer.push(query.revision);
1059
- if (query.pageToken !== undefined)
1060
- transfer.push(query.pageToken);
1061
- journal.record(transfer.join(' '));
1062
- try {
1063
- const result = await options.adapter.history(authorization, {
1064
- locator,
1065
- path,
1066
- ...(query.revision === undefined ? {} : { revision: query.revision }),
1067
- ...(query.pageToken === undefined ? {} : { pageToken: query.pageToken }),
1068
- });
1069
- journal.record(`outcome history ${result.kind}`);
1070
- if (fencedSince(locator, since))
1071
- return failure({ kind: 'room-not-readable', locator });
1072
- if (result.kind === 'scoped-refusal') {
1073
- const room = replicas.get(result.locator)?.confirmed.record;
1074
- if (room !== undefined)
1075
- await scoped(result, room, await openLocal());
1076
- }
1077
- if (result.kind === 'revoked-authorization')
1078
- await refuse('revoked-authorization');
1079
- return historyAnswer(result);
1080
- }
1081
- catch {
1082
- journal.record('outcome history transport-uncertainty');
1083
- return UNCERTAIN;
1084
- }
1085
- }
1086
- function queuedBlob(locator, path, localId) {
1087
- for (const batch of replicas.get(locator)?.queue ?? []) {
1088
- const change = batch.changes[queuedFile(batch, path, localId)];
1089
- if (change?.kind === 'binary')
1090
- return change.blob;
1091
- }
1092
- return null;
1093
- }
1094
- function binaryRoom(request) {
1095
- if (request.kind === 'path')
1096
- return request.locator;
1097
- const scope = options.adapter.referrerScope(request.referrer);
1098
- return scope?.kind === 'room' ? scope.locator : null;
1099
- }
1100
- async function readBinary(request) {
1101
- if (closed || refusal !== null)
1102
- return UNCERTAIN;
1103
- try {
1104
- await ensureAuthorization();
1105
- }
1106
- catch {
1107
- return UNCERTAIN;
1108
- }
1109
- if (closed || authorization === undefined || refusal !== null)
1110
- return UNCERTAIN;
1111
- const since = fencings;
1112
- journal.record(request.kind === 'path'
1113
- ? `transfer binary ${request.locator} ${request.path}`
1114
- : `transfer binary ${request.fileRef}`);
1115
- try {
1116
- const result = await options.adapter.binary(authorization, request);
1117
- journal.record(`outcome binary ${result.kind}`);
1118
- const locator = binaryRoom(request);
1119
- if (locator !== null && fencedSince(locator, since))
1120
- return failure({ kind: 'room-not-readable', locator });
1121
- if (result.kind === 'scoped-refusal') {
1122
- const room = replicas.get(result.locator)?.confirmed.record;
1123
- if (room !== undefined)
1124
- await scoped(result, room, await openLocal());
1125
- }
1126
- if (result.kind === 'revoked-authorization')
1127
- await refuse('revoked-authorization');
1128
- return binaryAnswer(result);
1129
- }
1130
- catch {
1131
- journal.record('outcome binary transport-uncertainty');
1132
- return UNCERTAIN;
1133
- }
1134
- }
1135
- async function readBinaryPath(locator, path, revision) {
1136
- await ready;
1137
- if (revision !== undefined)
1138
- return readBinary({ kind: 'path', locator, path, revision });
1139
- const visible = replicas.get(locator)?.visible;
1140
- const held = visible?.binaries[path];
1141
- if (visible === undefined || held === undefined)
1142
- return absentBinary(path);
1143
- if (held.state === 'pending') {
1144
- const blob = queuedBlob(locator, path, held.localId);
1145
- return blob === null ? absentBinary(path) : { kind: 'binary', blob };
1146
- }
1147
- const record = binaryRecord(path, held, visible.revisions[path]);
1148
- if (record.state !== 'accepted')
1149
- return absentBinary(path);
1150
- const replica = replicas.get(locator);
1151
- const queued = (replica?.queue ?? []).flatMap((batch) => batch.changes);
1152
- const holds = (at) => {
1153
- const kept = replica?.confirmed.record.binaries[at];
1154
- return (kept?.state === 'accepted' &&
1155
- kept.fileRef === record.fileRef &&
1156
- replica?.confirmed.record.revisions[at] === record.revision);
1157
- };
1158
- let confirmed = path;
1159
- for (let index = queued.length - 1; index >= 0 && !holds(confirmed); index -= 1) {
1160
- const change = queued[index];
1161
- if (change.kind === 'move' && change.to === confirmed)
1162
- confirmed = change.path;
1163
- }
1164
- return readBinary({
1165
- kind: 'path',
1166
- locator,
1167
- path: confirmed,
1168
- revision: record.revision,
1169
- fileRef: record.fileRef,
1170
- });
1171
- }
1172
- async function readBinaryReference(reference) {
1173
- await ready;
1174
- return readBinary({
1175
- kind: 'reference',
1176
- fileRef: reference.fileRef,
1177
- referrer: reference.referrer,
1178
- });
1179
- }
1180
- function declaredAgents() {
1181
- for (const capability of capabilities) {
1182
- if (capability.conversationAgents !== undefined)
1183
- return capability.conversationAgents;
1184
- }
1185
- return undefined;
1186
- }
1187
- function declaredAction(name) {
1188
- for (const capability of capabilities) {
1189
- for (const action of capability.actions ?? []) {
1190
- if (action.name === name)
1191
- return action;
1192
- }
1193
- }
1194
- return undefined;
1195
- }
1196
- async function invokeAction(name, input) {
1197
- await ready;
1198
- if (closed || refusal !== null)
1199
- return UNCERTAIN;
1200
- if (declaredAction(name) === undefined)
1201
- return undeclared(name);
1202
- try {
1203
- await ensureAuthorization();
1204
- }
1205
- catch {
1206
- return UNCERTAIN;
1207
- }
1208
- if (closed || authorization === undefined || refusal !== null)
1209
- return UNCERTAIN;
1210
- journal.record(`transfer action ${name}`);
1211
- try {
1212
- const result = await options.adapter.action(authorization, { name, input });
1213
- if (result.kind === 'scoped-refusal') {
1214
- const room = replicas.get(result.locator)?.confirmed.record;
1215
- if (room !== undefined)
1216
- await scoped(result, room, await openLocal());
1217
- }
1218
- if (result.kind === 'revoked-authorization')
1219
- await refuse('revoked-authorization');
1220
- journal.record(`outcome action ${result.kind}`);
1221
- if (result.kind === 'rejected')
1222
- journal.record(`refusal rejected ${result.code}`);
1223
- return calledResult(result);
1224
- }
1225
- catch {
1226
- journal.record('outcome action transport-uncertainty');
1227
- return UNCERTAIN;
1228
- }
1229
- }
1230
- function continuing() {
1231
- return !closed && !discoveryPaused;
1232
- }
1233
- function reachedBy(locator, roomVersion) {
1234
- const held = replicas.get(locator);
1235
- return (held !== undefined &&
1236
- options.adapter.reached(locator, held.confirmed.record.roomVersion, roomVersion));
1237
- }
1238
- function writtenAfter(locator, roomVersion, path) {
1239
- const written = replicas.get(locator)?.confirmed.record.written[path];
1240
- return (written !== undefined &&
1241
- options.adapter.reached(locator, written, roomVersion) &&
1242
- !options.adapter.reached(locator, roomVersion, written));
1243
- }
1244
- async function pullRefresh(authorized, confirmed, live) {
1245
- if (!live())
1246
- return unconfirmed;
1247
- try {
1248
- const result = await refreshRoom(options.adapter, authorized, confirmed, (models, held) => (live() ? remodel(confirmed.record.locator, models, held) : held), live);
1249
- const detail = result.kind === 'advanced' ? result.confirmed.record.roomVersion : result.kind;
1250
- journal.record(`transfer refresh ${confirmed.record.locator} ${detail}`);
1251
- return result;
1252
- }
1253
- catch (error) {
1254
- journal.record(`transfer refresh ${confirmed.record.locator} transport-uncertainty`);
1255
- throw error;
1256
- }
1257
- }
1258
- function staging(local, live) {
1259
- return {
1260
- held: (locator) => transfers.get(locator) ?? null,
1261
- staged: (record) => local.staged(record),
1262
- stage: (record, page) => exclusive(async () => {
1263
- if (!live())
1264
- return false;
1265
- await local.stage(record, page);
1266
- transfers.set(record.locator, record);
1267
- return true;
1268
- }),
1269
- abandon: (locator) => exclusive(async () => {
1270
- if (!live())
1271
- return;
1272
- await local.abandon(locator);
1273
- transfers.delete(locator);
1274
- }),
1275
- };
1276
- }
1277
- function reusable(room) {
1278
- const record = replicas.get(room.locator)?.confirmed.record;
1279
- if (record === undefined || record.replica.selection !== room.replica.selection)
1280
- return null;
1281
- return { documents: record.documents, revisions: record.revisions };
1282
- }
1283
- async function pullBootstrap(authorized, room, local, live) {
1284
- if (!live())
1285
- return unconfirmed;
1286
- try {
1287
- const result = await bootstrapRoom(options.adapter, authorized, room, {
1288
- collection: modelOf(room.locator),
1289
- selection: modelOf(room.locator, 'typed-selection'),
1290
- }, (models, held) => (live() ? remodel(room.locator, models, held) : held), live, staging(local, live), reusable(room));
1291
- const detail = result.kind === 'staged' ? result.confirmed.record.roomVersion : result.kind;
1292
- journal.record(`transfer bootstrap ${room.locator} ${detail}`);
1293
- return result;
1294
- }
1295
- catch (error) {
1296
- journal.record(`transfer bootstrap ${room.locator} transport-uncertainty`);
1297
- throw error;
1298
- }
1299
- }
1300
- async function advance(room, local, authorized, live) {
1301
- const held = replicas.get(room.locator);
1302
- if (held !== undefined) {
1303
- const refreshed = await pullRefresh(authorized, held.confirmed, live);
1304
- if (!live())
1305
- return unconfirmed;
1306
- if (refreshed.kind === 'still-current') {
1307
- stale.delete(room.locator);
1308
- if (sourceRefusals.has(room.locator))
1309
- return null;
1310
- if (unreadable.delete(room.locator)) {
1311
- scopedRefusals.delete(room.locator);
1312
- list(room, true);
1313
- emitRooms();
29
+ const socket = createSocket(adapter, journal, options.authorization);
30
+ const presence = createPresence();
31
+ const store = createStore({
32
+ database: {
33
+ async ask(request) {
34
+ try {
35
+ return await options.database.ask(request);
1314
36
  }
1315
- return null;
1316
- }
1317
- if (refreshed.kind === 'advanced') {
1318
- if (!(await publish(local, room, refreshed.confirmed, { base: held.confirmed }, live))) {
1319
- const now = replicas.get(room.locator)?.confirmed.record.roomVersion;
1320
- const reached = now !== undefined &&
1321
- options.adapter.reached(room.locator, now, refreshed.confirmed.record.roomVersion);
1322
- return reached ? null : advance(room, local, authorized, live);
37
+ catch (error) {
38
+ if (refusedForSpace(error))
39
+ filled(runtime);
40
+ throw error;
1323
41
  }
1324
- await retainModel(local, room, 'collection', modelOf(room.locator));
1325
- return null;
1326
- }
1327
- if (refreshed.kind !== 'beyond-horizon')
1328
- return refreshed;
1329
- if (opened !== null) {
1330
- owed.add(room.locator);
1331
- return unconfirmed;
1332
- }
1333
- }
1334
- const bootstrapped = await pullBootstrap(authorized, room, local, live);
1335
- if (!live())
1336
- return unconfirmed;
1337
- if (bootstrapped.kind !== 'staged')
1338
- return bootstrapped;
1339
- await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored }, live);
1340
- return null;
1341
- }
1342
- async function withhold(withheld, room, local, progress) {
1343
- if (withheld.kind === 'unconfirmed')
1344
- return;
1345
- if (withheld.kind === 'refused')
1346
- stale.delete(room.locator);
1347
- else
1348
- stale.add(room.locator);
1349
- if (withheld.kind === 'transport-uncertainty' || withheld.kind === 'retryable-refusal') {
1350
- const reset = withheld.kind === 'retryable-refusal' ? withheld.reset : undefined;
1351
- repairable.set(room.locator, reset);
1352
- repairLater(room.locator, reset === undefined ? { again: true } : { at: Date.parse(reset) });
1353
- }
1354
- else
1355
- repairable.delete(room.locator);
1356
- if (withheld.kind === 'scoped-refusal') {
1357
- await scoped(withheld, room, local);
1358
- }
1359
- else if (withheld.kind === 'transport-uncertainty') {
1360
- progress.reachable = false;
1361
- }
1362
- else if (withheld.kind === 'retryable-refusal') {
1363
- journal.record(`refusal ${withheld.kind} ${withheld.code}`);
1364
- }
1365
- else if (withheld.kind === 'room-not-readable') {
1366
- unreadable.add(room.locator);
1367
- list(room, false);
1368
- emitRooms();
1369
- }
1370
- else if (withheld.kind === 'refused') {
1371
- refusedSource(room, withheld);
1372
- }
1373
- else if (withheld.kind === 'revoked-authorization') {
1374
- await refuse('revoked-authorization');
1375
- }
1376
- }
1377
- function refusedSource(room, { refusal }) {
1378
- sourceRefusals.set(room.locator, {
1379
- code: refusal.rule,
1380
- retryable: false,
1381
- fields: {
1382
- file: refusal.file,
1383
- ...(refusal.location === undefined ? {} : { location: refusal.location }),
1384
- ...(refusal.referrers === undefined ? {} : { referrers: refusal.referrers }),
1385
- },
1386
- });
1387
- declarationRefusals.delete(room.locator);
1388
- unreadable.add(room.locator);
1389
- list(room, false);
1390
- emitRooms();
1391
- journal.record(`source refused ${room.locator} ${refusal.rule} ${refusal.file}`);
1392
- }
1393
- function leaving(batch, result) {
1394
- if (result.kind === 'expired')
1395
- return { batch, returned: returnedBy('expired') };
1396
- return {
1397
- batch,
1398
- returned: {
1399
- kind: result.kind,
1400
- code: result.code,
1401
- fields: result.fields,
1402
- retryable: result.retryable,
1403
42
  },
1404
- };
1405
- }
1406
- function logAccepted(locator, submitted, accepted) {
1407
- journal.record(`outcome ${locator} ${submitted.id} accepted ${accepted.roomVersion}` +
1408
- (accepted.author === undefined ? '' : ` author ${accepted.author}`) +
1409
- (accepted.time === undefined ? '' : ` time ${accepted.time}`));
1410
- }
1411
- async function adoptAccepted(room, local, submitted, accepted) {
1412
- if (!continuing())
1413
- return unconfirmed;
1414
- const current = replicas.get(room.locator);
1415
- if (current === undefined || !current.queue.some((batch) => batch.id === submitted.id)) {
1416
- return null;
1417
- }
1418
- const held = current.confirmed.record.roomVersion;
1419
- logAccepted(room.locator, submitted, accepted);
1420
- const applied = options.adapter.reached(room.locator, held, accepted.roomVersion)
1421
- ? { kind: 'staged', confirmed: current.confirmed }
1422
- : applyReturned(current.confirmed, submitted, accepted, options.adapter.follows(room.locator, held, accepted.roomVersion)
1423
- ? accepted.roomVersion
1424
- : held, accepted.roomVersion);
1425
- if (applied.kind !== 'staged') {
1426
- const state = pendings.get(submitted.id);
1427
- await local.accept(room.locator, submitted.id, accepted.roomVersion);
1428
- if (state !== undefined && !fences.has(room.locator))
1429
- pendings.set(submitted.id, { ...state, accepted: accepted.roomVersion });
1430
- emitQueue(room.locator);
1431
- return applied;
1432
- }
1433
- const set = await settle(local, room.locator, current, applied.confirmed, current.queue.filter((batch) => batch.id !== submitted.id), { room: true });
1434
- pendings.delete(submitted.id);
1435
- unreadable.delete(room.locator);
1436
- sourceRefusals.delete(room.locator);
1437
- declarationRefusals.delete(room.locator);
1438
- list(room, true);
1439
- publishChangeSet(set);
1440
- moveTo({ ...status, ...attention() });
1441
- return null;
1442
- }
1443
- async function adopted(room, local, submitted, accepted) {
1444
- const failed = await exclusive(() => adoptAccepted(room, local, submitted, accepted));
1445
- if (failed === null)
1446
- return true;
1447
- if (failed.kind === 'refused' && continuing())
1448
- refusedSource(room, failed);
1449
- return false;
1450
- }
1451
- async function submitRoom(room, local, authorized, progress, signal) {
1452
- while (continuing() && authorization !== undefined && !signal.aborted) {
1453
- const replica = replicas.get(room.locator);
1454
- const head = replica?.queue[0];
1455
- if (replica === undefined || head === undefined)
1456
- return 'done';
1457
- if (pendings.get(head.id)?.accepted !== undefined)
1458
- return 'done';
1459
- const state = pendings.get(head.id);
1460
- const { submission, lost: earlier } = state ?? {
1461
- submission: { state: 'waiting' },
1462
- lost: false,
1463
- };
1464
- if (submission.state === 'reset' && Date.now() < Date.parse(submission.reset)) {
1465
- progress.complete = false;
1466
- return { at: Date.parse(submission.reset) };
1467
- }
1468
- if (writesHeld()) {
1469
- progress.complete = false;
1470
- journal.record(`submission ${room.locator} ${head.id} held`);
1471
- return 'done';
1472
- }
1473
- const lost = earlier || submission.state === 'submitted';
1474
- if (lost && pastHorizon(head.id)) {
1475
- await discardPending(room, local, signal);
1476
- return 'done';
1477
- }
1478
- let result;
1479
- journal.record(`submission ${room.locator} ${head.id}`);
1480
- await exclusive(() => mark(local, room.locator, head.id, { state: 'submitted' }, lost));
1481
- if (discoveryPaused || fences.has(room.locator))
1482
- return 'done';
1483
- if (signal.aborted || writesHeld()) {
1484
- await exclusive(() => mark(local, room.locator, head.id, submission, earlier));
1485
- if (signal.aborted)
1486
- return 'done';
1487
- progress.complete = false;
1488
- journal.record(`submission ${room.locator} ${head.id} held`);
1489
- return 'done';
1490
- }
1491
- const opensBefore = openSignals;
1492
- const answered = awaitingAnswer(room.locator);
1493
- try {
1494
- result = await options.adapter.mutate(authorized, {
1495
- locator: room.locator,
1496
- changeBatch: head,
1497
- ...(state?.upload === undefined ? {} : { upload: state.upload }),
1498
- }, (upload) => exclusive(() => keepUpload(local, room.locator, head.id, upload)));
1499
- }
1500
- catch {
1501
- answered();
1502
- progress.complete = false;
1503
- if (continuing())
1504
- progress.reachable = false;
1505
- return 'again';
1506
- }
1507
- if (signal.aborted) {
1508
- answered();
1509
- return 'done';
1510
- }
1511
- if (result.kind !== 'accepted' || !continuing())
1512
- answered();
1513
- if (!continuing())
1514
- return 'done';
1515
- if (result.kind === 'transport-uncertainty') {
1516
- progress.complete = false;
1517
- progress.reachable = false;
1518
- return 'again';
1519
- }
1520
- if (result.kind === 'room-not-readable') {
1521
- progress.complete = false;
1522
- unreadable.add(room.locator);
1523
- list(room, false);
1524
- emitRooms();
1525
- return 'done';
1526
- }
1527
- if (result.kind === 'revoked-authorization') {
1528
- await refuse('revoked-authorization');
1529
- return 'done';
1530
- }
1531
- if (result.kind === 'scoped-refusal') {
1532
- await scoped(result, room, local);
1533
- progress.complete = false;
1534
- return 'done';
1535
- }
1536
- if (result.kind === 'write-halted') {
1537
- journal.record(`outcome ${room.locator} ${head.id} write-halted`);
1538
- await exclusive(() => mark(local, room.locator, head.id, { state: 'waiting' }, lost));
1539
- if (serviceMode === 'open' && openSignals !== opensBefore)
1540
- continue;
1541
- haltedRefusal = true;
1542
- progress.complete = false;
1543
- return 'done';
1544
- }
1545
- if (result.kind === 'conflicted' ||
1546
- result.kind === 'rejected' ||
1547
- result.kind === 'expired' ||
1548
- result.kind === 'retryable-refusal') {
1549
- if (result.kind === 'expired' && lost && result.restored !== true) {
1550
- journal.record(`outcome ${room.locator} ${head.id} expired`);
1551
- await discardPending(room, local, signal);
1552
- return 'done';
1553
- }
1554
- if (result.kind === 'expired') {
1555
- await exclusive(() => mark(local, room.locator, head.id, { state: 'waiting' }, false));
1556
- const withheld = await advance(room, local, authorized, continuing);
1557
- if (withheld !== null) {
1558
- await withhold(withheld, room, local, progress);
1559
- return 'done';
1560
- }
1561
- }
1562
- journal.record(`outcome ${room.locator} ${head.id} ${result.kind}` +
1563
- (result.kind === 'conflicted' && result.roomVersion !== undefined
1564
- ? ` ${result.roomVersion}`
1565
- : ''));
1566
- if (result.kind !== 'expired')
1567
- journal.record(`refusal ${result.kind} ${result.code}`);
1568
- }
1569
- if (result.kind === 'retryable-refusal') {
1570
- const reset = result.reset;
1571
- progress.complete = false;
1572
- await exclusive(() => mark(local, room.locator, head.id, reset === undefined ? { state: 'waiting' } : { state: 'reset', reset }, lost));
1573
- return reset === undefined ? 'again' : { at: Date.parse(reset) };
1574
- }
1575
- if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired') {
1576
- const left = leaving(head, result);
1577
- await exclusive(async () => {
1578
- if (!continuing())
1579
- return;
1580
- const current = replicas.get(room.locator);
1581
- if (current === undefined || !current.queue.some((batch) => batch.id === head.id)) {
1582
- return;
1583
- }
1584
- const set = await settle(local, room.locator, current, current.confirmed, current.queue.filter((batch) => batch.id !== head.id), {
1585
- leaving: (result.kind === 'expired' && landed(head, current.confirmed)) ||
1586
- (result.kind === 'conflicted' && landed(head, current.confirmed, result.affected))
1587
- ? { ...left, returned: null }
1588
- : left,
1589
- });
1590
- publishChangeSet(set);
1591
- moveTo({ ...status, ...attention() });
1592
- });
1593
- if (result.kind === 'expired')
1594
- continue;
1595
- const withheld = await advance(room, local, authorized, continuing);
1596
- if (withheld !== null) {
1597
- await withhold(withheld, room, local, progress);
1598
- return 'done';
1599
- }
1600
- continue;
1601
- }
1602
- const kept = await adopted(room, local, head, result).finally(answered);
1603
- if (!kept) {
1604
- progress.complete = false;
1605
- return 'done';
1606
- }
1607
- }
1608
- return 'done';
1609
- }
1610
- function pastHorizon(identity) {
1611
- return (outcomeRetention !== null && identityTime(identity) + outcomeRetention * 1000 <= Date.now());
1612
- }
1613
- async function discardPending(room, local, signal) {
1614
- const { locator } = room;
1615
- const discarded = await exclusive(async () => {
1616
- if (fences.has(locator))
1617
- return false;
1618
- const before = replicas.get(locator);
1619
- const queue = before?.queue ?? queuesWithoutReplica.get(locator) ?? [];
1620
- fences.set(locator, { at: discoveries, erased: false });
1621
- lastFenced.set(locator, ++fencings);
1622
- try {
1623
- await local.discard(locator);
1624
- }
1625
- finally {
1626
- fences.delete(locator);
1627
- }
1628
- for (const batch of queue)
1629
- pendings.delete(batch.id);
1630
- queuesWithoutReplica.delete(locator);
1631
- const after = before === undefined ? null : replicaOf(before.confirmed, [], before);
1632
- if (after !== null)
1633
- replicas.set(locator, after);
1634
- journal.record(`room discarded ${locator}`);
1635
- publishChangeSet(changeSet(locator, before ?? null, after, { queue: true }));
1636
- moveTo({ ...status, ...attention() });
1637
- return true;
1638
- });
1639
- if (!discarded)
1640
- return;
1641
- const progress = { complete: true, reachable: true };
1642
- await roomTask(locator, async (live) => {
1643
- await Promise.race([
1644
- reload(room, local, progress, () => live() && !signal.aborted),
1645
- abandonedOn(signal),
1646
- ]);
1647
- });
1648
- if (signal.aborted)
1649
- return;
1650
- await rest(progress);
1651
- }
1652
- function awaitingAnswer(locator) {
1653
- let release = () => { };
1654
- const awaited = new Promise((resolve) => {
1655
- release = resolve;
1656
- });
1657
- answering.set(locator, { generation, answered: awaited });
1658
- return () => {
1659
- if (answering.get(locator)?.answered === awaited)
1660
- answering.delete(locator);
1661
- release();
1662
- };
1663
- }
1664
- async function retainModel(local, room, attached, next) {
1665
- const key = modelKey(room.locator, attached);
1666
- const previous = modelOf(room.locator, attached);
1667
- const heldBefore = replicas.get(room.locator)?.confirmed.record;
1668
- if (JSON.stringify(previous) === JSON.stringify(next) &&
1669
- (heldBefore === undefined ||
1670
- (JSON.stringify(heldBefore.operations) === JSON.stringify(room.operations) &&
1671
- JSON.stringify(heldBefore.replica) === JSON.stringify(room.replica) &&
1672
- JSON.stringify(heldBefore.typedSelection) ===
1673
- JSON.stringify(room.typedSelection ?? null))))
1674
- return;
1675
- if (next.status === 'unavailable') {
1676
- invalidModels.add(key);
1677
- liveModels.delete(key);
1678
- }
1679
- await exclusive(async () => {
1680
- if (!continuing())
1681
- return;
1682
- const held = replicas.get(room.locator);
1683
- if (held !== undefined) {
1684
- const declared = {
1685
- ...held.confirmed.record,
1686
- operations: room.operations,
1687
- replica: room.replica,
1688
- typedSelection: room.typedSelection ?? null,
1689
- ...(attached === 'collection' ? { model: next } : { selectionModel: next }),
1690
- };
1691
- const reclassified = sameMembership(declared, held.confirmed.record)
1692
- ? { kind: 'staged', confirmed: confirmedOf(declared, held.confirmed) }
1693
- : readReclassified(declared, held.confirmed);
1694
- const record = reclassified.kind === 'staged'
1695
- ? declared
1696
- : {
1697
- ...declared,
1698
- typedSelection: held.confirmed.record.typedSelection,
1699
- };
1700
- const read = reclassified.kind === 'deferred'
1701
- ? { kind: 'staged', confirmed: confirmedOf(record, held.confirmed) }
1702
- : reclassified;
1703
- await local.write({ next: record, previous: held.confirmed.record });
1704
- if (read.kind === 'staged') {
1705
- replicas.set(room.locator, replicaOf(read.confirmed, held.queue, held));
1706
- if (declarationRefusals.delete(room.locator)) {
1707
- sourceRefusals.delete(room.locator);
1708
- unreadable.delete(room.locator);
1709
- }
1710
- }
1711
- else if (read.kind === 'refused') {
1712
- replicas.set(room.locator, { ...held, confirmed: { ...held.confirmed, record } });
1713
- refusedSource(room, read);
1714
- declarationRefusals.add(room.locator);
1715
- }
1716
- }
1717
- models.set(key, next);
1718
- if (next.status === 'current') {
1719
- liveModels.set(key, JSON.stringify(next.snapshot));
1720
- invalidModels.delete(key);
1721
- }
1722
- list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
1723
- if (held === undefined)
1724
- emitRooms();
1725
- else
1726
- publishChangeSet(changeSet(room.locator, held, replicas.get(room.locator) ?? null, { room: true }));
1727
- });
1728
- }
1729
- async function scoped(result, room, local) {
1730
- scopedRefusals.set(room.locator, {
1731
- code: result.code,
1732
- fields: result.fields,
1733
- retryable: result.retryable,
1734
- });
1735
- let scopedAway = room;
1736
- if (result.scope === 'model')
1737
- await retainModel(local, room, 'collection', {
1738
- status: 'unavailable',
1739
- reason: 'not-readable',
1740
- });
1741
- else if (result.scope !== 'operation') {
1742
- unreadable.add(room.locator);
1743
- scopedAway = {
1744
- ...room,
1745
- replica: { ...room.replica, admission: 'unavailable' },
1746
- operations: {
1747
- ...room.operations,
1748
- ...(result.scope === 'content' ? { read: [] } : {}),
1749
- ...(result.scope === 'sync' ? { sync: [] } : {}),
1750
- },
1751
- };
1752
- await retainModel(local, scopedAway, 'collection', modelOf(room.locator));
1753
- }
1754
- if (!continuing())
1755
- return;
1756
- list(scopedAway, scopedAway.replica.admission === 'admitted' && !unreadable.has(room.locator));
1757
- emitRooms();
1758
- journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
1759
- }
1760
- function heldRooms(listed) {
1761
- return listed.flatMap((room) => {
1762
- const record = replicas.get(room.locator)?.confirmed.record;
1763
- if (record === undefined || record.replica.selection !== room.replica.selection)
1764
- return [];
1765
- return [
1766
- {
1767
- locator: room.locator,
1768
- roomVersion: record.roomVersion,
1769
- documents: record.documents,
1770
- revisions: record.revisions,
1771
- },
1772
- ];
1773
- });
1774
- }
1775
- async function synchronize(listed, local, progress, attempt, live) {
1776
- const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(room, local, progress)));
1777
- if (!live())
1778
- return;
1779
- const ready = listed.filter((_, index) => {
1780
- const outcome = prepared[index];
1781
- return outcome?.status === 'fulfilled' && outcome.value;
1782
- });
1783
- if (attempt === 'opened') {
1784
- options.adapter.roomStream?.hold(heldRooms(ready));
1785
- handed = true;
1786
- }
1787
- discovering?.release();
1788
- const loaded = await Promise.allSettled(ready
1789
- .filter((room) => attempt === 'unstreamed' || !replicas.has(room.locator))
1790
- .map((room) => roomTask(room.locator, (held) => loadRoom(room, local, progress, held))));
1791
- const failed = [...prepared, ...loaded].find((room) => room.status === 'rejected');
1792
- if (failed !== undefined)
1793
- throw failed.reason;
1794
- }
1795
- async function prepareRoom(room, local, progress) {
1796
- if (closed || authorization === undefined) {
1797
- progress.complete = false;
1798
- return false;
1799
- }
1800
- const prior = replicas.get(room.locator)?.confirmed.record;
1801
- if (prior !== undefined && prior.replica.selection !== room.replica.selection) {
1802
- list(prior, false);
1803
- emitRooms();
1804
- journal.record(`selection changed ${room.locator}`);
1805
- progress.complete = false;
1806
- return false;
1807
- }
1808
- if (prior !== undefined)
1809
- await retainModel(local, room, 'collection', modelOf(room.locator));
1810
- if (discoveryPaused || authorization === undefined)
1811
- return false;
1812
- if (room.replica.admission !== 'admitted') {
1813
- if (replicas.has(room.locator))
1814
- progress.complete = false;
1815
- return false;
1816
- }
1817
- return true;
1818
- }
1819
- async function caughtUp(room, local, progress, live) {
1820
- const held = replicas.get(room.locator)?.confirmed.record.roomVersion;
1821
- if (held === undefined || authorization === undefined || !live())
1822
- return;
1823
- const behind = [announced.get(room.locator), room.roomVersion].some((later) => later !== undefined && !options.adapter.reached(room.locator, held, later));
1824
- if (!behind)
1825
- return;
1826
- const withheld = await advance(room, local, authorization, live);
1827
- if (withheld !== null)
1828
- await withhold(withheld, room, local, progress);
1829
- }
1830
- function revoked(locator) {
1831
- return ['collection', 'typed-selection'].some((attached) => {
1832
- const model = modelOf(locator, attached);
1833
- return model.status === 'unavailable' && model.reason === 'revoked';
1834
- });
1835
- }
1836
- async function loadRoom(room, local, progress, live) {
1837
- if (!live() || authorization === undefined)
1838
- return;
1839
- if (replicas.has(room.locator) && revoked(room.locator)) {
1840
- await reload(room, local, progress, live);
1841
- return;
1842
- }
1843
- const withheld = await advance(room, local, authorization, live);
1844
- if (withheld !== null) {
1845
- await withhold(withheld, room, local, progress);
1846
- return;
1847
- }
1848
- await caughtUp(room, local, progress, live);
1849
- }
1850
- async function reload(room, local, progress, live) {
1851
- if (!live() || authorization === undefined)
1852
- return;
1853
- const bootstrapped = await pullBootstrap(authorization, room, local, live);
1854
- if (!live())
1855
- return;
1856
- if (bootstrapped.kind !== 'staged') {
1857
- await withhold(bootstrapped, room, local, progress);
1858
- return;
1859
- }
1860
- await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored }, live);
1861
- await caughtUp(room, local, progress, live);
1862
- }
1863
- async function discoverRooms(local, progress, attempt, live) {
1864
- if (closed || authorization === undefined) {
1865
- notifyReady();
1866
- return;
1867
- }
1868
- moveTo(transferring(status));
1869
- discoveries += 1;
1870
- const started = discoveries;
1871
- let result;
1872
- try {
1873
- result = await options.adapter.discover(authorization);
1874
- }
1875
- catch {
1876
- result = { kind: 'transport-uncertainty' };
1877
- }
1878
- if (!live()) {
1879
- progress.complete = false;
1880
- notifyReady();
1881
- return;
1882
- }
1883
- journal.record(`connection discover ${result.kind}`);
1884
- if (result.kind === 'transport-uncertainty') {
1885
- for (const room of rooms.values()) {
1886
- await retainModel(local, room, 'collection', cached(modelOf(room.locator)));
1887
- if (room.typedSelection !== null) {
1888
- await retainModel(local, room, 'typed-selection', cached(modelOf(room.locator, 'typed-selection')));
1889
- }
1890
- }
1891
- progress.reachable = false;
1892
- progress.complete = false;
1893
- notifyReady();
1894
- return;
1895
- }
1896
- if (result.kind === 'contract-unavailable') {
1897
- journal.record(`connection contract unavailable ${result.code}`);
1898
- await refuse('missing-required-guarantee', {
1899
- code: result.code,
1900
- fields: result.fields,
1901
- retryable: result.retryable,
1902
- });
1903
- notifyReady();
1904
- return;
1905
- }
1906
- if (result.kind === 'revoked-authorization') {
1907
- await refuse('revoked-authorization');
1908
- notifyReady();
1909
- return;
1910
- }
1911
- for (const room of result.rooms) {
1912
- if (room.operations === undefined ||
1913
- !['read', 'sync', 'write', 'delete'].every((operation) => Array.isArray(room.operations[operation]) &&
1914
- room.operations[operation].every((scope) => typeof scope === 'string')) ||
1915
- room.replica === undefined ||
1916
- typeof room.replica.selection !== 'string' ||
1917
- room.replica.selection.length === 0 ||
1918
- !['admitted', 'unavailable'].includes(room.replica.admission)) {
1919
- journal.record(`invalid model or replica declaration ${room.locator}`);
1920
- await refuse('missing-required-guarantee');
1921
- notifyReady();
1922
- return;
1923
- }
1924
- if (!declaredSelection(room)) {
1925
- journal.record(`invalid typed selection declaration ${room.locator}`);
1926
- await refuse('missing-required-guarantee');
1927
- notifyReady();
1928
- return;
1929
- }
1930
- }
1931
- if (refusal !== null) {
1932
- refusal = null;
1933
- emitRefusal();
1934
- }
1935
- const previousCapabilities = capabilities;
1936
- capabilities = result.capabilities;
1937
- outcomeRetention = result.retention.outcome;
1938
- notifyReady();
1939
- if (JSON.stringify(result.providerLimits) !== JSON.stringify(limits) ||
1940
- JSON.stringify(result.capabilities) !== JSON.stringify(previousCapabilities)) {
1941
- limits = result.providerLimits;
1942
- await local.declare(limits, capabilities);
1943
- }
1944
- const signedIn = result.member ?? null;
1945
- if (JSON.stringify(signedIn) !== JSON.stringify(member)) {
1946
- await local.keepMember(signedIn);
1947
- member = signedIn;
1948
- emitMember();
1949
- }
1950
- await synchronize(await applyDiscovery(result.rooms, started), local, progress, attempt, live);
1951
- }
1952
- async function ensureAuthorization() {
1953
- if (authorization !== undefined)
1954
- return;
1955
- try {
1956
- authorization = await options.adapter.authorize();
1957
- journal.record('connection authorize');
1958
- }
1959
- catch (error) {
1960
- journal.record('connection authorize transport-uncertainty');
1961
- throw error;
1962
- }
1963
- }
1964
- async function admittedRead(work) {
1965
- if (roomReads.generation !== generation) {
1966
- roomReads = { generation, free: ROOM_READS, waiting: [] };
1967
- }
1968
- const reads = roomReads;
1969
- while (reads.free === 0)
1970
- await new Promise((admit) => reads.waiting.push(admit));
1971
- reads.free -= 1;
1972
- try {
1973
- await work();
1974
- }
1975
- finally {
1976
- reads.free += 1;
1977
- reads.waiting.shift()?.();
1978
- }
1979
- }
1980
- function roomTask(locator, work) {
1981
- return task(roomLane(locator), (live) => admittedRead(() => work(live)));
1982
- }
1983
- function task(lane, work) {
1984
- if (stopping)
1985
- return Promise.resolve();
1986
- const held = lanes.get(lane);
1987
- const current = held?.generation === generation ? held : { generation, chain: Promise.resolve() };
1988
- const turn = current.generation;
1989
- const live = () => turn === generation && continuing();
1990
- const run = current.chain.then(() => work(live)).catch(() => undefined);
1991
- current.chain = run;
1992
- lanes.set(lane, current);
1993
- working.add(run);
1994
- void run.finally(() => working.delete(run));
1995
- return run;
1996
- }
1997
- function sync(attempt) {
1998
- return task(OPENING_LANE, async (live) => {
1999
- if (!live()) {
2000
- notifyReady();
2001
- return;
2002
- }
2003
- const progress = { complete: true, reachable: true };
2004
- const gate = discover();
2005
- if (attempt === 'opened')
2006
- opened = generation;
2007
- underway = attempt === 'opened' ? { generation, progress } : null;
2008
- if (attempt === 'opened')
2009
- streamed = progress;
2010
- complete = false;
2011
- recorded = false;
2012
- moveTo(transferring(status));
2013
- handed = false;
2014
- try {
2015
- const local = await openLocal();
2016
- if (!live())
2017
- return;
2018
- await ensureAuthorization();
2019
- if (!live())
2020
- return;
2021
- await discoverRooms(local, progress, attempt, live);
2022
- }
2023
- catch {
2024
- progress.complete = false;
2025
- if (attempt === 'opened' && !handed)
2026
- progress.reachable = false;
2027
- }
2028
- finally {
2029
- gate.release();
2030
- notifyReady();
2031
- }
2032
- if (!live())
2033
- return;
2034
- if (attempt !== 'opened') {
2035
- await finishOpening(progress, live);
2036
- return;
2037
- }
2038
- if (handed || closed || progress.reachable)
2039
- return;
2040
- underway = null;
2041
- opened = null;
2042
- journal.record('connection reopen');
2043
- await rest(progress, live);
2044
- options.adapter.roomStream?.reopen();
2045
- });
2046
- }
2047
- function closedSocket(revoked) {
2048
- const opened = socketOpen;
2049
- socketOpen = false;
2050
- if (revoked) {
2051
- void refuse('revoked-authorization');
2052
- return;
2053
- }
2054
- complete = false;
2055
- if (streamed !== null)
2056
- streamed.complete = false;
2057
- moveTo({
2058
- ...status,
2059
- state: status.state === 'synced' ? 'syncing' : status.state,
2060
- providerUnreachable: status.providerUnreachable || !opened,
2061
- });
2062
- }
2063
- function applyOpening(expired) {
2064
- const progress = underway?.generation === generation ? underway.progress : null;
2065
- const cycle = progress ?? { complete: true, reachable: true };
2066
- const replacing = reloadNow((room) => expired.includes(room.locator), cycle);
2067
- return task(OPENING_LANE, async (live) => {
2068
- underway = null;
2069
- if (!live())
2070
- return;
2071
- if (progress === null) {
2072
- await replacing;
2073
- await rest(cycle, live);
2074
- return;
2075
- }
2076
- await roomsCarried(expired);
2077
- if (!live())
2078
- return;
2079
- if (opened === generation)
2080
- opened = null;
2081
- const replaced = new Set(owed);
2082
- owed.clear();
2083
- try {
2084
- const local = await openLocal();
2085
- const held = [...discovered.values()].filter((room) => replicas.has(room.locator));
2086
- const reloading = held.filter((room) => !expired.includes(room.locator) &&
2087
- (replaced.has(room.locator) || revoked(room.locator)));
2088
- const reloads = Promise.allSettled(reloading.map((room) => roomTask(room.locator, (current) => reload(room, local, progress, current))));
2089
- const reloaded = [...(await reloads), ...(await replacing)];
2090
- if (progress.reachable) {
2091
- for (const room of held) {
2092
- if (!expired.includes(room.locator) && !reloading.includes(room)) {
2093
- await confirmModels(room, local);
2094
- }
2095
- }
2096
- }
2097
- const failed = reloaded.find((outcome) => outcome.status === 'rejected');
2098
- if (failed !== undefined)
2099
- throw failed.reason;
2100
- }
2101
- catch {
2102
- progress.complete = false;
2103
- progress.reachable = false;
2104
- }
2105
- if (live())
2106
- await finishOpening(progress, live);
2107
- });
2108
- }
2109
- async function reloadNow(replaced, progress) {
2110
- try {
2111
- const local = await openLocal();
2112
- return await Promise.allSettled([...discovered.values()]
2113
- .filter((room) => replicas.has(room.locator) && replaced(room))
2114
- .map((room) => roomTask(room.locator, (live) => reload(room, local, progress, live))));
2115
- }
2116
- catch {
2117
- progress.reachable = false;
2118
- return [];
2119
- }
2120
- }
2121
- async function confirmModels(room, local) {
2122
- for (const attached of ['collection', 'typed-selection']) {
2123
- const model = modelOf(room.locator, attached);
2124
- if (model.status === 'cached') {
2125
- await retainModel(local, room, attached, { ...model, status: 'current' });
2126
- }
2127
- }
2128
- }
2129
- function submitLater(locator) {
2130
- if (localSaves)
2131
- return;
2132
- void recovery.attempt(`submit ${locator}`, (signal) => submitPass(locator, signal));
2133
- }
2134
- async function submitPass(locator, signal) {
2135
- const room = discovered.get(locator);
2136
- if (closed || stopping || discoveryPaused || room === undefined)
2137
- return 'done';
2138
- const progress = { complete: true, reachable: true };
2139
- let next;
2140
- try {
2141
- await ensureAuthorization();
2142
- if (authorization === undefined)
2143
- return 'done';
2144
- next = await submitRoom(room, await openLocal(), authorization, progress, signal);
2145
- }
2146
- catch {
2147
- progress.reachable = false;
2148
- next = 'again';
2149
- }
2150
- if (signal.aborted)
2151
- return 'done';
2152
- await rest(progress);
2153
- return next === 'again' && !socketOpen ? 'done' : next;
2154
- }
2155
- function repairLater(locator, when) {
2156
- if (!socketOpen || repairing.has(locator))
2157
- return;
2158
- void recovery.attempt(`repair ${locator}`, (signal) => repairPass(locator, signal), when);
2159
- }
2160
- async function repairPass(locator, signal) {
2161
- const room = discovered.get(locator);
2162
- if (!socketOpen || closed || stopping || discoveryPaused || !stale.has(locator))
2163
- return 'done';
2164
- if (room === undefined || room.replica.admission !== 'admitted')
2165
- return 'done';
2166
- const progress = { complete: true, reachable: true };
2167
- repairing.add(locator);
2168
- try {
2169
- const local = await openLocal();
2170
- await roomTask(locator, async (live) => {
2171
- const current = () => live() && !signal.aborted;
2172
- if (!current() || authorization === undefined)
2173
- return;
2174
- const withheld = await Promise.race([
2175
- advance(room, local, authorization, current),
2176
- abandonedOn(signal),
2177
- ]);
2178
- if (withheld !== null && current())
2179
- await withhold(withheld, room, local, progress);
2180
- });
2181
- }
2182
- catch {
2183
- stale.add(locator);
2184
- progress.reachable = false;
2185
- }
2186
- finally {
2187
- repairing.delete(locator);
2188
- }
2189
- if (signal.aborted)
2190
- return 'done';
2191
- await rest(progress);
2192
- if (!stale.has(locator)) {
2193
- if ((replicas.get(locator)?.queue.length ?? 0) > 0)
2194
- submitLater(locator);
2195
- return 'done';
2196
- }
2197
- if (!repairable.has(locator))
2198
- return 'done';
2199
- const reset = repairable.get(locator);
2200
- return reset === undefined ? 'again' : { at: Date.parse(reset) };
2201
- }
2202
- function resendLater() {
2203
- if (!socketOpen)
2204
- return;
2205
- void recovery.attempt('resend', resendPass, { again: true });
2206
- }
2207
- async function resendPass(signal) {
2208
- if (!socketOpen || closed || stopping || discoveryPaused)
2209
- return 'done';
2210
- const reading = { complete: true, reachable: true };
2211
- try {
2212
- await conversations.resend(reading);
2213
- }
2214
- catch {
2215
- reading.reachable = false;
2216
- }
2217
- if (signal.aborted)
2218
- return 'done';
2219
- return reading.reachable && reading.complete ? 'done' : 'again';
2220
- }
2221
- function submitAll() {
2222
- for (const [locator, replica] of replicas) {
2223
- if (replica.queue.length > 0)
2224
- submitLater(locator);
2225
- }
2226
- }
2227
- async function finishOpening(progress, live) {
2228
- try {
2229
- if (!live()) {
2230
- progress.complete = false;
2231
- return;
2232
- }
2233
- submitAll();
2234
- for (const locator of stale)
2235
- if (repairable.has(locator))
2236
- repairLater(locator, {});
2237
- await conversations.reconcile();
2238
- if (status.providerUnreachable)
2239
- conversations.reconnected();
2240
- const reading = { complete: true, reachable: true };
2241
- await conversations.catchUp(reading);
2242
- if (progress.reachable && reading.reachable)
2243
- await conversations.resend(reading);
2244
- if (!reading.reachable) {
2245
- progress.reachable = false;
2246
- resendLater();
2247
- }
2248
- }
2249
- catch {
2250
- progress.complete = false;
2251
- }
2252
- finally {
2253
- if (live()) {
2254
- complete = progress.complete;
2255
- await rest(progress, live);
2256
- }
2257
- }
2258
- }
2259
- async function rest(progress, live = () => !closed) {
2260
- if (!live())
2261
- return;
2262
- let lastCompleted = status.lastCompleted;
2263
- let synced = complete && stale.size === 0 && !pending();
2264
- if (synced && !recorded) {
2265
- const completedAt = new Date().toISOString();
2266
- try {
2267
- await (await openLocal()).complete(completedAt);
2268
- if (!live())
2269
- return;
2270
- recorded = true;
2271
- lastCompleted = completedAt;
2272
- }
2273
- catch {
2274
- synced = false;
2275
- }
2276
- }
2277
- moveTo({
2278
- state: pending() ? 'pending' : synced && complete ? 'synced' : 'syncing',
2279
- lastCompleted,
2280
- providerUnreachable: !progress.reachable,
2281
- ...attention(),
2282
- });
2283
- }
2284
- function discover() {
2285
- let release = () => { };
2286
- const done = new Promise((resolve) => {
2287
- release = resolve;
2288
- });
2289
- discovering = { generation, done, release };
2290
- return discovering;
2291
- }
2292
- function applyRoom(locator, roomVersion) {
2293
- announced.set(locator, roomVersion);
2294
- return task(roomLane(locator), async (live) => {
2295
- if (discovering?.generation === generation)
2296
- await discovering.done;
2297
- const saving = answering.get(locator);
2298
- if (saving?.generation === generation)
2299
- await saving.answered;
2300
- if (!live() || authorization === undefined)
2301
- return;
2302
- const room = discovered.get(locator);
2303
- const held = replicas.get(locator);
2304
- if (room === undefined || room.replica.admission !== 'admitted')
2305
- return;
2306
- if (held !== undefined &&
2307
- (held.confirmed.record.replica.selection !== room.replica.selection ||
2308
- options.adapter.reached(locator, held.confirmed.record.roomVersion, roomVersion))) {
2309
- return;
2310
- }
2311
- const during = underway?.generation === generation ? underway.progress : null;
2312
- const progress = during ?? { complete: true, reachable: true };
2313
- if (during === null)
2314
- moveTo(transferring(status));
2315
- try {
2316
- const local = await openLocal();
2317
- await admittedRead(async () => {
2318
- if (!live() || authorization === undefined)
2319
- return;
2320
- const withheld = await advance(room, local, authorization, live);
2321
- if (withheld !== null)
2322
- await withhold(withheld, room, local, progress);
2323
- });
2324
- }
2325
- catch {
2326
- stale.add(locator);
2327
- }
2328
- finally {
2329
- if (during === null)
2330
- await rest(progress, live);
2331
- }
2332
- });
2333
- }
2334
- function roomsCarried(replacing) {
2335
- const replaced = new Set(replacing.map(roomLane));
2336
- return Promise.all([...lanes]
2337
- .filter(([lane, held]) => lane !== OPENING_LANE && !replaced.has(lane) && held.generation === generation)
2338
- .map(([, held]) => held.chain));
2339
- }
2340
- const receipts = {
2341
- heads: async () => (await openLocal()).receivedHeads(),
2342
- parts: async (key, count) => (await openLocal()).receivedParts(key, count),
2343
- keep: async (key, head, part) => (await openLocal()).keepReceived(key, head, part),
2344
- drop: async (keys) => (await openLocal()).dropReceived(keys),
2345
- };
2346
- function observeStream() {
2347
- const stream = options.adapter.roomStream;
2348
- if (stream === undefined || withdrawStream !== undefined)
2349
- return;
2350
- withdrawStream = stream.observe((event) => {
2351
- if (closed || stopping)
2352
- return;
2353
- if (event.kind === 'opened') {
2354
- socketOpen = true;
2355
- generation += 1;
2356
- conversations.reopened();
2357
- recovery.resume();
2358
- void sync('opened');
2359
- }
2360
- else if (event.kind === 'closed')
2361
- closedSocket(event.revoked);
2362
- else if (event.kind === 'opening')
2363
- void applyOpening(event.expired);
2364
- else
2365
- void applyRoom(event.locator, event.roomVersion);
2366
- }, receipts);
2367
- }
2368
- function writesHeld() {
2369
- return serviceMode === 'write-halted' || haltedRefusal;
2370
- }
2371
- function signalled(mode) {
2372
- if (closed)
2373
- return;
2374
- if (mode === 'open')
2375
- openSignals += 1;
2376
- const releasing = mode === 'open' && (haltedRefusal || serviceMode === 'write-halted');
2377
- if (mode === 'open')
2378
- haltedRefusal = false;
2379
- if (mode !== serviceMode) {
2380
- serviceMode = mode;
2381
- journal.record(`service mode ${mode}`);
2382
- for (const listener of serviceModeListeners)
2383
- listener(mode);
2384
- }
2385
- if (releasing)
2386
- submitAll();
2387
- }
2388
- function observeConversations() {
2389
- const stream = options.adapter.conversations;
2390
- if (stream === undefined || withdrawConversations !== undefined)
2391
- return;
2392
- withdrawConversations = stream.observe((event) => {
2393
- if (conversations.receive(event)) {
2394
- void ready.then(scheduleCurrency);
2395
- return;
2396
- }
2397
- if (event.kind !== 'gap' || conversations.current())
2398
- return;
2399
- show();
2400
- scheduleCurrency();
2401
- });
2402
- }
2403
- function scheduleCurrency() {
2404
- if (currencyQueued === generation || closed || stopping)
2405
- return;
2406
- currencyQueued = generation;
2407
- void task(CONVERSATION_LANE, runCurrency);
2408
- }
2409
- async function runCurrency(live) {
2410
- if (currencyQueued === generation)
2411
- currencyQueued = null;
2412
- if (!live())
2413
- return;
2414
- await conversations.reconcile();
2415
- if (conversations.current()) {
2416
- show();
2417
- return;
2418
- }
2419
- const progress = { complete: false, reachable: !status.providerUnreachable };
2420
- moveTo(transferring(status));
2421
- try {
2422
- await conversations.catchUp(progress);
2423
- }
2424
- catch {
2425
- progress.reachable = false;
2426
- }
2427
- await rest(progress, live);
2428
- }
2429
- function close() {
2430
- if (closed)
2431
- return;
2432
- closed = true;
2433
- withdrawStream?.();
2434
- withdrawStream = undefined;
2435
- withdrawConversations?.();
2436
- withdrawConversations = undefined;
2437
- withdrawServiceMode?.();
2438
- conversations.close();
2439
- void recovery.retire();
2440
- store?.close();
2441
- void opening?.then((opened) => {
2442
- opened.close();
2443
- }, () => { });
2444
- roomListeners.clear();
2445
- refusalListeners.clear();
2446
- storageLossListeners.clear();
2447
- statusListeners.clear();
2448
- serviceModeListeners.clear();
2449
- memberListeners.clear();
2450
- readSide.close();
2451
- queueSubscriptions.clear();
2452
- roomDraftListeners.clear();
2453
- presentationListeners.clear();
2454
- }
2455
- async function stop() {
2456
- stopping = true;
2457
- await recovery.retire();
2458
- await Promise.all(working);
2459
- await mutations;
2460
- close();
2461
- }
2462
- const withdrawServiceMode = options.adapter.serviceMode?.observe(signalled);
2463
- observeConversations();
2464
- options.signal?.addEventListener('abort', close, { once: true });
2465
- if (options.signal?.aborted)
2466
- close();
2467
- observeStream();
2468
- void openLocal().then(() => {
2469
- if (capabilities.length > 0)
2470
- notifyReady();
2471
- }, () => {
2472
- notifyReady();
2473
- });
2474
- if (options.adapter.roomStream === undefined)
2475
- void sync('unstreamed');
2476
- function planned(input, reach) {
2477
- return planOf(input, roomFacts(reach), planReach(reach));
2478
- }
2479
- function watchPlan(plan, deliver) {
2480
- materialize(reachedRooms(plan));
2481
- return readSide.watch(plan, identityOf(plan), deliver);
2482
- }
2483
- async function searched(input, reach) {
2484
- const plan = searchPlanOf(input);
2485
- const selected = plan.documents === undefined && reach === null
2486
- ? null
2487
- : (await rowsQuery(filterOf(plan.documents ?? {}, roomFacts(reach), planReach(reach)))).documents;
2488
- if (selected === null)
2489
- materialize(null);
2490
- return searchIndex.search(reach === null || reach.conversations ? plan : { ...plan, conversations: [] }, selected);
2491
- }
2492
- const watch = (topic, input, deliver) => {
2493
- if (topic === 'room-drafts') {
2494
- const listener = { notify: deliver, ready: false };
2495
- roomDraftListeners.add(listener);
2496
- void exclusive(async () => {
2497
- await openLocal();
2498
- if (closed || !roomDraftListeners.has(listener))
2499
- return;
2500
- listener.ready = true;
2501
- }).then(() => {
2502
- if (closed || !listener.ready || !roomDraftListeners.has(listener))
2503
- return;
2504
- listener.notify(snapshotRoomDrafts());
2505
- }, () => { });
2506
- return () => {
2507
- roomDraftListeners.delete(listener);
2508
- };
2509
- }
2510
- if (topic === 'conversation') {
2511
- return conversations.watch(input[0], input[1], deliver);
2512
- }
2513
- if (topic === 'conversations')
2514
- return conversations.watchList(deliver);
2515
- if (topic === 'agents')
2516
- return conversations.watchAgents(deliver);
2517
- if (topic === 'presentation') {
2518
- const listener = {
2519
- app: input[0],
2520
- notify: deliver,
2521
- ready: false,
2522
- };
2523
- presentationListeners.add(listener);
2524
- void exclusive(async () => {
2525
- await openLocal();
2526
- }).then(() => {
2527
- if (closed || !presentationListeners.has(listener))
2528
- return;
2529
- listener.ready = true;
2530
- listener.notify(presentationOf(listener.app));
2531
- }, () => { });
2532
- return () => {
2533
- presentationListeners.delete(listener);
2534
- };
2535
- }
2536
- if (topic === 'rooms') {
2537
- roomListeners.add(deliver);
2538
- deliver(listed());
2539
- return () => {
2540
- roomListeners.delete(deliver);
2541
- };
2542
- }
2543
- if (topic === 'connection-refusal') {
2544
- refusalListeners.add(deliver);
2545
- deliver(refusal);
2546
- return () => {
2547
- refusalListeners.delete(deliver);
2548
- };
2549
- }
2550
- if (topic === 'storage-loss') {
2551
- storageLossListeners.add(deliver);
2552
- deliver(storageLoss);
2553
- return () => {
2554
- storageLossListeners.delete(deliver);
2555
- };
2556
- }
2557
- if (topic === 'sync-status') {
2558
- statusListeners.add(deliver);
2559
- deliver(shown);
2560
- return () => {
2561
- statusListeners.delete(deliver);
2562
- };
2563
- }
2564
- if (topic === 'service-mode') {
2565
- serviceModeListeners.add(deliver);
2566
- deliver(serviceMode);
2567
- return () => {
2568
- serviceModeListeners.delete(deliver);
2569
- };
2570
- }
2571
- if (topic === 'member') {
2572
- memberListeners.add(deliver);
2573
- deliver(member);
2574
- return () => {
2575
- memberListeners.delete(deliver);
2576
- };
2577
- }
2578
- if (topic === 'queue') {
2579
- const queue = { locator: input[0], notify: deliver };
2580
- queueSubscriptions.add(queue);
2581
- queue.notify(entriesOf(queue.locator));
2582
- return () => {
2583
- queueSubscriptions.delete(queue);
2584
- };
2585
- }
2586
- return watchPlan(planned(input[0], null), deliver);
2587
- };
2588
- const md = {
2589
- loaded() {
2590
- return openLocal().then(() => undefined);
2591
43
  },
2592
- rooms() {
2593
- return listed();
44
+ roomTypes,
45
+ builtIn,
46
+ typedPaths,
47
+ persistence: shell.persistence,
48
+ lost: presence.lost,
49
+ opening: (local) => open(runtime, local),
50
+ unpublished(error) {
51
+ journal.record(`publication failed ${error instanceof Error ? error.name : 'unknown'}`);
52
+ uncaught(error);
2594
53
  },
2595
- query: ((input) => rowsQuery(planned(input, null))),
2596
- search: (input) => searched(input, null),
2597
- types(locator) {
2598
- return {
2599
- collection: modelTypes(modelOf(locator)),
2600
- typedSelection: rooms.get(locator)?.typedSelection === undefined ||
2601
- rooms.get(locator)?.typedSelection === null
2602
- ? null
2603
- : modelTypes(modelOf(locator, 'typed-selection')),
2604
- };
54
+ changed(set) {
55
+ if (set.unindexed.length > 0)
56
+ prepare(runtime, set.unindexed);
57
+ for (const locator of set.due)
58
+ submitLater(runtime, locator);
59
+ return publishChangeSet(runtime, set);
2605
60
  },
2606
- roomDraft: {
2607
- list() {
2608
- return exclusive(async () => {
2609
- await openLocal();
2610
- return snapshotRoomDrafts();
2611
- }).then((listed) => {
2612
- publishRoomDrafts(true);
2613
- return listed;
2614
- });
2615
- },
2616
- read(room, path) {
2617
- const record = roomDrafts.get(room)?.get(path);
2618
- return record === undefined ? null : roomDraftOf(record);
2619
- },
2620
- write(room, path, revision, input) {
2621
- return exclusive(async () => {
2622
- const parts = readParts(input);
2623
- if (path === '' || normalize(path) !== path)
2624
- throw runtimeError('room-draft-malformed');
2625
- const local = await openLocal();
2626
- const current = roomDrafts.get(room)?.get(path);
2627
- if ((current?.revision ?? null) !== revision) {
2628
- return staleWrite(current === undefined ? null : roomDraftOf(current));
2629
- }
2630
- const file = parts.file === undefined
2631
- ? undefined
2632
- : await heldFile(parts.file.blob, binaryBase(replicas.get(room)?.visible, path));
2633
- const record = {
2634
- locator: room,
2635
- path,
2636
- revision: roomDraftRevision(),
2637
- parts: held(current?.parts, parts, file),
2638
- returned: current?.returned ?? null,
2639
- };
2640
- await local.keepRoomDraft(record);
2641
- rememberRoomDraft(record);
2642
- publishChangeSet(changeSet(room, null, null, { drafts: [path] }));
2643
- return { outcome: 'written', roomDraft: roomDraftOf(record) };
2644
- });
2645
- },
2646
- discard(room, path, revision) {
2647
- return exclusive(async () => {
2648
- const local = await openLocal();
2649
- const current = roomDrafts.get(room)?.get(path);
2650
- if (current === undefined || current.revision !== revision) {
2651
- return staleWrite(current === undefined ? null : roomDraftOf(current));
2652
- }
2653
- await local.discardRoomDraft(room, path);
2654
- forgetRoomDraft(room, path);
2655
- publishChangeSet(changeSet(room, null, null, { drafts: [path] }));
2656
- moveTo({ ...status, ...attention() });
2657
- return { outcome: 'written', roomDraft: null };
2658
- });
2659
- },
2660
- },
2661
- conversation: conversations.surface,
2662
- chatDraft: conversations.chatDraft,
2663
- presentation: {
2664
- read(app) {
2665
- return exclusive(async () => {
2666
- await openLocal();
2667
- return presentationOf(app);
2668
- });
61
+ deliverReadiness: (owed) => deliverOwedReadiness(runtime, owed),
62
+ spaceFreed: () => spaceFreed(runtime),
63
+ });
64
+ const recovery = (options.recovery ?? createRecovery()).scope(ROOM_ATTEMPTS);
65
+ const runtime = {
66
+ store,
67
+ socket,
68
+ presence,
69
+ journal,
70
+ recovery,
71
+ shell,
72
+ localSaves: adapter.localSaves === true,
73
+ roomTypes,
74
+ builtIn,
75
+ typedPaths,
76
+ writeRule: (declaration) => writeRule(declaration, adapter.pathRule ?? (() => true), adapter.localSaves === true),
77
+ usableWhenHeld: options.usableWhenHeld ?? [],
78
+ build: options.build ?? '',
79
+ conversations: createLiveConversations({
80
+ call: (name, input) => invokeAction(runtime, name, input),
81
+ history: (request) => readConversationHistory(runtime, request),
82
+ durably: store.durably,
83
+ local: store.open,
84
+ again: () => {
85
+ void socket.ready.then(() => scheduleCurrency(runtime));
2669
86
  },
2670
- write(app, value) {
2671
- return exclusive(async () => {
2672
- const local = await openLocal();
2673
- const stored = structuredClone(value);
2674
- await local.present({ app, value: stored });
2675
- presentations.set(app, stored);
2676
- publishChangeSet(changeSet('', null, null, { presentation: app }));
2677
- });
87
+ settled: () => {
88
+ show(runtime);
2678
89
  },
2679
- },
2680
- save(room, named, writtenBy) {
2681
- return exclusive(() => saveRoomDrafts(room, named, writtenBy));
2682
- },
2683
- history(locator, path, query) {
2684
- return readHistory(locator, path, query);
2685
- },
2686
- binaryFile: {
2687
- read: readBinaryPath,
2688
- readReference: readBinaryReference,
2689
- },
2690
- call(name, input) {
2691
- return invokeAction(name, input);
2692
- },
2693
- reached(locator, roomVersion, path) {
2694
- return path === undefined
2695
- ? reachedBy(locator, roomVersion)
2696
- : writtenAfter(locator, roomVersion, path);
2697
- },
2698
- log() {
2699
- return journal.export();
2700
- },
2701
- persistence() {
2702
- return options.shell.persistentStorage;
2703
- },
2704
- observe: observing(watch),
2705
- async reauthorize() {
2706
- if (refusal === null || !refusal.reauthorizationOffered)
2707
- return;
2708
- journal.record('connection reauthorize');
2709
- await Promise.all([...lanes.values()]
2710
- .filter((held) => held.generation === generation)
2711
- .map((held) => held.chain));
2712
- await mutations;
2713
- authorization = undefined;
2714
- discoveryPaused = false;
2715
- if (options.adapter.roomStream === undefined)
2716
- await sync('unstreamed');
2717
- else
2718
- await task(OPENING_LANE, ensureAuthorization);
2719
- },
2720
- };
2721
- const reachable = {
2722
- md,
2723
- watch,
2724
- referrerScope: (referrer) => options.adapter.referrerScope(referrer),
2725
- plan: planned,
2726
- query: (plan) => rowsQuery(plan),
2727
- watchPlan,
2728
- search: searched,
90
+ stream: socket.conversations,
91
+ publish: store.changed,
92
+ online: socket.reached,
93
+ full: store.space.full,
94
+ closed: socket.closed,
95
+ unanswered: () => resendLater(runtime),
96
+ recovery: recovery.scope(),
97
+ }),
98
+ liveQueries: createLiveQueries((plan, cover) => answeredPlan(runtime, plan, cover), store.covering),
99
+ figures: createFigures({
100
+ cover: () => figuresCover(runtime),
101
+ rooms: (rooms, since) => roomTallies(runtime, rooms, since),
102
+ conversations: (conversations, since) => store.ask({ kind: 'conversation.tallies', conversations, since }),
103
+ }),
104
+ lastAnswers: readAnswers({
105
+ database: store,
106
+ build: options.build ?? '',
107
+ unkept: adapter.unkeptReads ?? [],
108
+ leading: adapter.leadingReads ?? [],
109
+ recovery: recovery.scope(),
110
+ call: (name, input) => called(runtime, name, input),
111
+ online: socket.reached,
112
+ streaming: socket.isOpen,
113
+ closed: socket.closed,
114
+ full: store.space.full,
115
+ filled: () => filled(runtime),
116
+ }),
2729
117
  };
2730
- return { md, stop, lose: loseRooms, watch, within: (reach) => narrowed(reachable, reach) };
118
+ start(runtime, options.signal);
119
+ return composedRuntime(runtime);
2731
120
  }