@celljs/ta-relay 4.10.0 → 4.12.0

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 (118) hide show
  1. package/README.en.md +13 -1
  2. package/README.md +13 -1
  3. package/esm/common/index.d.ts +11 -0
  4. package/esm/common/index.js +11 -0
  5. package/esm/common/relay-blobs.d.ts +54 -0
  6. package/esm/common/relay-blobs.js +153 -0
  7. package/esm/common/relay-card.d.ts +23 -0
  8. package/esm/common/relay-card.js +30 -0
  9. package/esm/common/relay-content.d.ts +104 -0
  10. package/esm/common/relay-content.js +316 -0
  11. package/esm/common/relay-conversation.d.ts +59 -0
  12. package/esm/common/relay-conversation.js +9 -0
  13. package/esm/common/relay-faces.d.ts +32 -0
  14. package/esm/common/relay-faces.js +208 -0
  15. package/esm/common/relay-hub-util.d.ts +91 -0
  16. package/esm/common/relay-hub-util.js +164 -0
  17. package/esm/common/relay-hub.d.ts +125 -0
  18. package/esm/common/relay-hub.js +438 -0
  19. package/esm/common/relay-hubs-connection.d.ts +98 -0
  20. package/esm/common/relay-hubs-connection.js +505 -0
  21. package/esm/common/relay-hubs-protocol.d.ts +130 -0
  22. package/esm/common/relay-hubs-protocol.js +2 -0
  23. package/esm/common/relay-hubs.d.ts +61 -0
  24. package/esm/common/relay-hubs.js +351 -0
  25. package/esm/common/relay-identity.d.ts +46 -0
  26. package/esm/common/relay-identity.js +126 -0
  27. package/esm/common/relay-protocol.d.ts +211 -2
  28. package/esm/common/relay-protocol.js +53 -0
  29. package/esm/common/relay-room-chat.d.ts +109 -0
  30. package/esm/common/relay-room-chat.js +176 -0
  31. package/esm/common/relay-socket.d.ts +8 -0
  32. package/esm/common/relay-socket.js +23 -2
  33. package/esm/guest/guest-i18n.d.ts +50 -0
  34. package/esm/guest/guest-i18n.js +103 -0
  35. package/esm/guest/guest-style.d.ts +1 -0
  36. package/esm/guest/guest-style.js +85 -0
  37. package/esm/guest/guest.d.ts +1 -0
  38. package/esm/guest/guest.js +384 -0
  39. package/esm/node/index.d.ts +2 -0
  40. package/esm/node/index.js +2 -0
  41. package/esm/node/relay-host.d.ts +25 -3
  42. package/esm/node/relay-host.js +115 -4
  43. package/esm/node/relay-hub-files.d.ts +12 -0
  44. package/esm/node/relay-hub-files.js +39 -0
  45. package/esm/node/relay-server.d.ts +46 -1
  46. package/esm/node/relay-server.js +227 -1
  47. package/esm/node/relay-store.d.ts +72 -0
  48. package/esm/node/relay-store.js +123 -2
  49. package/esm/node/relay-viewer.d.ts +7 -0
  50. package/esm/node/relay-viewer.js +33 -0
  51. package/esm/viewer/viewer-i18n.d.ts +56 -0
  52. package/esm/viewer/viewer-i18n.js +117 -0
  53. package/esm/viewer/viewer-markdown.d.ts +7 -0
  54. package/esm/viewer/viewer-markdown.js +198 -0
  55. package/esm/viewer/viewer-style.d.ts +1 -0
  56. package/esm/viewer/viewer-style.js +72 -0
  57. package/esm/viewer/viewer.d.ts +8 -0
  58. package/esm/viewer/viewer.js +378 -0
  59. package/lib/common/index.d.ts +11 -0
  60. package/lib/common/index.js +11 -0
  61. package/lib/common/relay-blobs.d.ts +55 -0
  62. package/lib/common/relay-blobs.js +157 -0
  63. package/lib/common/relay-card.d.ts +24 -0
  64. package/lib/common/relay-card.js +33 -0
  65. package/lib/common/relay-content.d.ts +105 -0
  66. package/lib/common/relay-content.js +320 -0
  67. package/lib/common/relay-conversation.d.ts +60 -0
  68. package/lib/common/relay-conversation.js +12 -0
  69. package/lib/common/relay-faces.d.ts +33 -0
  70. package/lib/common/relay-faces.js +211 -0
  71. package/lib/common/relay-hub-util.d.ts +92 -0
  72. package/lib/common/relay-hub-util.js +167 -0
  73. package/lib/common/relay-hub.d.ts +126 -0
  74. package/lib/common/relay-hub.js +442 -0
  75. package/lib/common/relay-hubs-connection.d.ts +99 -0
  76. package/lib/common/relay-hubs-connection.js +510 -0
  77. package/lib/common/relay-hubs-protocol.d.ts +131 -0
  78. package/lib/common/relay-hubs-protocol.js +3 -0
  79. package/lib/common/relay-hubs.d.ts +62 -0
  80. package/lib/common/relay-hubs.js +355 -0
  81. package/lib/common/relay-identity.d.ts +47 -0
  82. package/lib/common/relay-identity.js +129 -0
  83. package/lib/common/relay-protocol.d.ts +211 -2
  84. package/lib/common/relay-protocol.js +54 -1
  85. package/lib/common/relay-room-chat.d.ts +110 -0
  86. package/lib/common/relay-room-chat.js +180 -0
  87. package/lib/common/relay-socket.d.ts +8 -0
  88. package/lib/common/relay-socket.js +23 -2
  89. package/lib/guest/guest-i18n.d.ts +51 -0
  90. package/lib/guest/guest-i18n.js +106 -0
  91. package/lib/guest/guest-style.d.ts +2 -0
  92. package/lib/guest/guest-style.js +88 -0
  93. package/lib/guest/guest.d.ts +2 -0
  94. package/lib/guest/guest.js +386 -0
  95. package/lib/node/index.d.ts +2 -0
  96. package/lib/node/index.js +2 -0
  97. package/lib/node/relay-host.d.ts +25 -3
  98. package/lib/node/relay-host.js +115 -4
  99. package/lib/node/relay-hub-files.d.ts +13 -0
  100. package/lib/node/relay-hub-files.js +43 -0
  101. package/lib/node/relay-server.d.ts +46 -1
  102. package/lib/node/relay-server.js +226 -0
  103. package/lib/node/relay-store.d.ts +72 -0
  104. package/lib/node/relay-store.js +121 -0
  105. package/lib/node/relay-viewer.d.ts +8 -0
  106. package/lib/node/relay-viewer.js +32 -0
  107. package/lib/viewer/viewer-i18n.d.ts +57 -0
  108. package/lib/viewer/viewer-i18n.js +120 -0
  109. package/lib/viewer/viewer-markdown.d.ts +8 -0
  110. package/lib/viewer/viewer-markdown.js +201 -0
  111. package/lib/viewer/viewer-style.d.ts +2 -0
  112. package/lib/viewer/viewer-style.js +75 -0
  113. package/lib/viewer/viewer.d.ts +9 -0
  114. package/lib/viewer/viewer.js +381 -0
  115. package/package.json +5 -4
  116. package/viewer/frame.html +1 -0
  117. package/viewer/page.html +80 -0
  118. package/viewer/room.html +94 -0
@@ -0,0 +1,91 @@
1
+ import { type RelayIdentity, type RelayPublicIdentity } from './relay-identity.js';
2
+ /** What a link inviting into a room names (docs/design/ta-link.md 3.3); all of it in the fragment, which a browser does not send. */
3
+ export interface RelayHubLink {
4
+ relay: string;
5
+ room: string;
6
+ /** base64url, 32 bytes: what an ask proves and is sealed with. */
7
+ invite: string;
8
+ /** The identity id of the owner: the answer must be signed by it. */
9
+ owner: string;
10
+ title: string;
11
+ /** The owner's name, as they gave it. */
12
+ by: string;
13
+ }
14
+ /** One of a room, as its owner lists them in the roster. */
15
+ export interface RelayHubMember extends RelayPublicIdentity {
16
+ /** The id of the member in this room alone (not its identity). */
17
+ member: string;
18
+ owner?: boolean;
19
+ /** A guest in a browser (docs/design/ta-link.md 3.8): the others hear only what it says. */
20
+ guest?: boolean;
21
+ at: number;
22
+ }
23
+ export interface RelayHubRosterBody {
24
+ v: number;
25
+ members: RelayHubMember[];
26
+ }
27
+ /** What one asking to join says of itself, sealed with the key of the invitation and signed. */
28
+ export interface RelayHubAskBody extends RelayPublicIdentity {
29
+ member: string;
30
+ at: number;
31
+ /** Asks from a browser, without Ta: for the owner to know, and to admit as a guest. */
32
+ guest?: boolean;
33
+ }
34
+ /** What the owner gives one it admits, sealed for it alone: the key of the room, and what the room is. */
35
+ export interface RelayHubAnswerBody {
36
+ key: string;
37
+ kind: string;
38
+ title: string;
39
+ view?: string;
40
+ }
41
+ export interface RelayHubSigned<T> {
42
+ /** The member who signed it. */
43
+ m: string;
44
+ at: number;
45
+ b: T;
46
+ }
47
+ /** The keys of a room, made from its key `R` once. */
48
+ export interface RelayHubKeys {
49
+ seal: CryptoKey;
50
+ names: Uint8Array;
51
+ }
52
+ /** Links, keys, sealing and signatures of rooms (docs/design/ta-link.md 3.2, 3.3). */
53
+ export declare namespace RelayHubUtil {
54
+ /** `https://<relay>/r#v=1&r=<room>&i=<invite>&o=<owner>&n=<title>&by=<name>`. */
55
+ function link(link: RelayHubLink): string;
56
+ function is(text: string): boolean;
57
+ /** Throws on what is not a link of {@link link}. */
58
+ function parse(text: string): RelayHubLink;
59
+ function randomId(): string;
60
+ function randomKey(): string;
61
+ function keys(roomKey: string): Promise<RelayHubKeys>;
62
+ /** What the relay knows a key of the state by: HMAC of its name, 22 characters. */
63
+ function keyId(keys: RelayHubKeys, name: string): Promise<string>;
64
+ /** What proves an ask comes from one with the invitation; the relay keeps its {@link RelayKeys.hash}. */
65
+ function inviteProof(invite: string): Promise<string>;
66
+ function inviteKey(invite: string): Promise<CryptoKey>;
67
+ /** Signed by `identity` as `member`, then sealed with `key`. */
68
+ function seal<T>(key: CryptoKey, identity: RelayIdentity, member: string, body: T, at?: number): Promise<string>;
69
+ /**
70
+ * What {@link seal} sealed, once its signature checks with the signing key `signOf` gives for its member;
71
+ * undefined when it does not open, is not signed by that member, or is of another time than `now` (with `skewMs`).
72
+ */
73
+ function open<T>(key: CryptoKey, sealed: string, signOf: (member: string) => string | undefined, options?: {
74
+ now?: number;
75
+ skewMs?: number;
76
+ }): Promise<RelayHubSigned<T> | undefined>;
77
+ /** An ask: sealed with the key of the invitation, signed by the one who asks (its keys inside), whom the owner checks. */
78
+ function sealAsk(invite: string, identity: RelayIdentity, member: string, at?: number, guest?: boolean): Promise<string>;
79
+ /** Undefined for an ask that does not open with this invitation, or is not signed by the keys it gives. */
80
+ function openAsk(invite: string, sealed: string): Promise<RelayHubAskBody | undefined>;
81
+ /**
82
+ * The owner's answer to an ask: what the room is and its key, for the one who asked alone (ECDH of the two), signed by
83
+ * the owner; all of it sealed with the invitation the ask came with, so that the relay does not see who the owner is.
84
+ */
85
+ function sealAnswer(owner: RelayIdentity, room: string, ask: RelayHubAskBody, body: RelayHubAnswerBody, invite: string): Promise<string>;
86
+ /** Undefined unless it is signed by the owner the link names, and opens for this identity. */
87
+ function openAnswer(identity: RelayIdentity, room: string, member: string, ownerId: string, answer: string, invite: string): Promise<{
88
+ owner: RelayPublicIdentity;
89
+ body: RelayHubAnswerBody;
90
+ } | undefined>;
91
+ }
@@ -0,0 +1,164 @@
1
+ import { RelayBytes } from './relay-bytes.js';
2
+ import { RelayIdentityUtil, RelayKeys } from './relay-identity.js';
3
+ import { RELAY_ID, RELAY_ROOM_PATH } from './relay-protocol.js';
4
+ /** Links, keys, sealing and signatures of rooms (docs/design/ta-link.md 3.2, 3.3). */
5
+ export var RelayHubUtil;
6
+ (function (RelayHubUtil) {
7
+ /** `https://<relay>/r#v=1&r=<room>&i=<invite>&o=<owner>&n=<title>&by=<name>`. */
8
+ function link(link) {
9
+ const fragment = new URLSearchParams({ v: '1', r: link.room, i: link.invite, o: link.owner, n: link.title, by: link.by });
10
+ return `${link.relay}${RELAY_ROOM_PATH}#${fragment}`;
11
+ }
12
+ RelayHubUtil.link = link;
13
+ function is(text) {
14
+ try {
15
+ parse(text);
16
+ return true;
17
+ }
18
+ catch (_a) {
19
+ return false;
20
+ }
21
+ }
22
+ RelayHubUtil.is = is;
23
+ /** Throws on what is not a link of {@link link}. */
24
+ function parse(text) {
25
+ var _a, _b;
26
+ const url = new URL(text.trim());
27
+ const fragment = new URLSearchParams(url.hash.slice(1));
28
+ const [room, invite, owner] = ['r', 'i', 'o'].map(name => { var _a; return (_a = fragment.get(name)) !== null && _a !== void 0 ? _a : ''; });
29
+ if (!/^https?:$/.test(url.protocol) ||
30
+ url.pathname !== RELAY_ROOM_PATH ||
31
+ fragment.get('v') !== '1' ||
32
+ !RELAY_ID.test(room) ||
33
+ !/^[A-Za-z0-9_-]{43}$/.test(invite) ||
34
+ !/^[A-Za-z0-9_-]{22}$/.test(owner)) {
35
+ throw new Error('Not a link inviting into a room of Ta.');
36
+ }
37
+ return { relay: url.origin, room, invite, owner, title: ((_a = fragment.get('n')) !== null && _a !== void 0 ? _a : '').slice(0, 200), by: ((_b = fragment.get('by')) !== null && _b !== void 0 ? _b : '').slice(0, 100) };
38
+ }
39
+ RelayHubUtil.parse = parse;
40
+ function randomId() {
41
+ return RelayBytes.toBase64(RelayBytes.random(16));
42
+ }
43
+ RelayHubUtil.randomId = randomId;
44
+ function randomKey() {
45
+ return RelayBytes.toBase64(RelayBytes.random(32));
46
+ }
47
+ RelayHubUtil.randomKey = randomKey;
48
+ async function keys(roomKey) {
49
+ const key = RelayBytes.fromBase64(roomKey);
50
+ const none = new Uint8Array(0);
51
+ return {
52
+ seal: await RelayKeys.aesKey(await RelayKeys.hkdf(key, none, 'ta-room/1 seal')),
53
+ names: await RelayKeys.hkdf(key, none, 'ta-room/1 key'),
54
+ };
55
+ }
56
+ RelayHubUtil.keys = keys;
57
+ /** What the relay knows a key of the state by: HMAC of its name, 22 characters. */
58
+ async function keyId(keys, name) {
59
+ return (await RelayKeys.hmac(keys.names, name)).slice(0, 22);
60
+ }
61
+ RelayHubUtil.keyId = keyId;
62
+ /** What proves an ask comes from one with the invitation; the relay keeps its {@link RelayKeys.hash}. */
63
+ async function inviteProof(invite) {
64
+ return RelayBytes.toBase64(await RelayKeys.hkdf(RelayBytes.fromBase64(invite), new Uint8Array(0), 'ta-room/1 ask auth'));
65
+ }
66
+ RelayHubUtil.inviteProof = inviteProof;
67
+ async function inviteKey(invite) {
68
+ return RelayKeys.aesKey(await RelayKeys.hkdf(RelayBytes.fromBase64(invite), new Uint8Array(0), 'ta-room/1 ask seal'));
69
+ }
70
+ RelayHubUtil.inviteKey = inviteKey;
71
+ /** Signed by `identity` as `member`, then sealed with `key`. */
72
+ async function seal(key, identity, member, body, at = Date.now()) {
73
+ const p = JSON.stringify({ m: member, at, b: body });
74
+ return RelayKeys.seal(key, JSON.stringify({ p, s: await RelayIdentityUtil.sign(identity, p) }));
75
+ }
76
+ RelayHubUtil.seal = seal;
77
+ /**
78
+ * What {@link seal} sealed, once its signature checks with the signing key `signOf` gives for its member;
79
+ * undefined when it does not open, is not signed by that member, or is of another time than `now` (with `skewMs`).
80
+ */
81
+ async function open(key, sealed, signOf, options = {}) {
82
+ var _a;
83
+ try {
84
+ const envelope = JSON.parse(await RelayKeys.open(key, sealed));
85
+ const signed = JSON.parse(envelope.p);
86
+ const sign = typeof signed.m === 'string' ? signOf(signed.m) : undefined;
87
+ if (!sign || !(await RelayIdentityUtil.verify(sign, envelope.p, envelope.s))) {
88
+ return undefined;
89
+ }
90
+ if (options.skewMs !== undefined && Math.abs(((_a = options.now) !== null && _a !== void 0 ? _a : Date.now()) - Number(signed.at)) > options.skewMs) {
91
+ return undefined;
92
+ }
93
+ return signed;
94
+ }
95
+ catch (_b) {
96
+ return undefined;
97
+ }
98
+ }
99
+ RelayHubUtil.open = open;
100
+ /** An ask: sealed with the key of the invitation, signed by the one who asks (its keys inside), whom the owner checks. */
101
+ async function sealAsk(invite, identity, member, at = Date.now(), guest = false) {
102
+ const body = { ...RelayIdentityUtil.publicOf(identity), member, at, ...(guest ? { guest: true } : {}) };
103
+ return seal(await inviteKey(invite), identity, member, body, at);
104
+ }
105
+ RelayHubUtil.sealAsk = sealAsk;
106
+ /** Undefined for an ask that does not open with this invitation, or is not signed by the keys it gives. */
107
+ async function openAsk(invite, sealed) {
108
+ try {
109
+ const envelope = JSON.parse(await RelayKeys.open(await inviteKey(invite), sealed));
110
+ const signed = JSON.parse(envelope.p);
111
+ const body = signed.b;
112
+ if (!body ||
113
+ signed.m !== body.member ||
114
+ !RELAY_ID.test(String(body.member)) ||
115
+ !(await RelayIdentityUtil.check(body)) ||
116
+ !(await RelayIdentityUtil.verify(body.sign, envelope.p, envelope.s))) {
117
+ return undefined;
118
+ }
119
+ return {
120
+ ...RelayIdentityUtil.publicOf(body),
121
+ name: String(body.name).slice(0, 100),
122
+ member: body.member,
123
+ at: Number(body.at),
124
+ ...(body.guest === true ? { guest: true } : {}),
125
+ };
126
+ }
127
+ catch (_a) {
128
+ return undefined;
129
+ }
130
+ }
131
+ RelayHubUtil.openAsk = openAsk;
132
+ /**
133
+ * The owner's answer to an ask: what the room is and its key, for the one who asked alone (ECDH of the two), signed by
134
+ * the owner; all of it sealed with the invitation the ask came with, so that the relay does not see who the owner is.
135
+ */
136
+ async function sealAnswer(owner, room, ask, body, invite) {
137
+ const key = await RelayKeys.aesKey(await RelayIdentityUtil.agree(owner, ask.box, room, 'ta-room/1 answer'));
138
+ const d = await RelayKeys.seal(key, JSON.stringify(body));
139
+ const signed = `${room}\n${ask.member}\n${d}`;
140
+ const answer = JSON.stringify({ owner: RelayIdentityUtil.publicOf(owner), d, s: await RelayIdentityUtil.sign(owner, signed) });
141
+ return RelayKeys.seal(await inviteKey(invite), answer);
142
+ }
143
+ RelayHubUtil.sealAnswer = sealAnswer;
144
+ /** Undefined unless it is signed by the owner the link names, and opens for this identity. */
145
+ async function openAnswer(identity, room, member, ownerId, answer, invite) {
146
+ try {
147
+ const { owner, d, s } = JSON.parse(await RelayKeys.open(await inviteKey(invite), answer));
148
+ if (owner.id !== ownerId ||
149
+ !(await RelayIdentityUtil.check(owner)) ||
150
+ !(await RelayIdentityUtil.verify(owner.sign, `${room}\n${member}\n${d}`, s))) {
151
+ return undefined;
152
+ }
153
+ const key = await RelayKeys.aesKey(await RelayIdentityUtil.agree(identity, owner.box, room, 'ta-room/1 answer'));
154
+ const body = JSON.parse(await RelayKeys.open(key, d));
155
+ RelayBytes.fromBase64(body.key);
156
+ return { owner: { ...RelayIdentityUtil.publicOf(owner), name: String(owner.name).slice(0, 100) }, body };
157
+ }
158
+ catch (_a) {
159
+ return undefined;
160
+ }
161
+ }
162
+ RelayHubUtil.openAnswer = openAnswer;
163
+ })(RelayHubUtil || (RelayHubUtil = {}));
164
+ //# sourceMappingURL=relay-hub-util.js.map
@@ -0,0 +1,125 @@
1
+ import { type RelayHubAsk, type RelayHubEvent, type RelayHubFailure, type RelayHubRequest, type RelayHubRoster } from './relay-protocol.js';
2
+ /** Where a hub keeps a room: a Durable Object's storage, or a map in `ta relay`. Values are structured-cloned. */
3
+ export interface RelayHubStorage {
4
+ get<T>(key: string): Promise<T | undefined>;
5
+ put(key: string, value: unknown): Promise<void>;
6
+ delete(key: string): Promise<unknown>;
7
+ /** The values whose keys start with `prefix`. */
8
+ list<T>(options: {
9
+ prefix: string;
10
+ }): Promise<Map<string, T>>;
11
+ deleteAll(): Promise<void>;
12
+ /** When the room is deleted if nobody uses it (RELAY_HUB_IDLE_DAYS). */
13
+ setAlarm?(at: number): Promise<void>;
14
+ }
15
+ /** Who a connection is, once its first message said so. */
16
+ export type RelayHubWho = {
17
+ member: string;
18
+ } | {
19
+ ask: string;
20
+ };
21
+ /** A connection to the hub: `who` is kept with it (an attachment of the socket in a Durable Object, which sleeps). */
22
+ export interface RelayHubSocket {
23
+ /** The same for the same connection: what its rate is counted by. */
24
+ readonly key: unknown;
25
+ who: RelayHubWho | undefined;
26
+ send(text: string): void;
27
+ close(code: number, reason: string): void;
28
+ }
29
+ /** Close codes of a hub. */
30
+ export declare enum RelayHubCloseCode {
31
+ /** Not a member, or a wrong token. */
32
+ REFUSED = 4401,
33
+ /** No such room: never made, deleted, or past its time. */
34
+ GONE = 4404,
35
+ /** Removed by the owner, or the room was closed. */
36
+ REMOVED = 4410,
37
+ /** The ask was answered: connect again as a member, or not. */
38
+ ANSWERED = 4411,
39
+ /** A first message that says nobody. */
40
+ INVALID = 4400
41
+ }
42
+ interface HubMeta {
43
+ owner: string;
44
+ createdAt: number;
45
+ touched: number;
46
+ invite?: {
47
+ hash: string;
48
+ expiresAt: number;
49
+ };
50
+ keys: number;
51
+ size: number;
52
+ }
53
+ type HubMembers = Record<string, {
54
+ hash: string;
55
+ at: number;
56
+ }>;
57
+ type HubAsks = Record<string, {
58
+ hash: string;
59
+ d: string;
60
+ at: number;
61
+ answer?: string;
62
+ refused?: boolean;
63
+ }>;
64
+ /**
65
+ * The hub of a room at the relay (docs/design/ta-link.md 3.4): who its members are (by the hashes of their
66
+ * tokens), the asks to join until the owner answers, the roster and the shared state, sealed. It passes what a
67
+ * member sends to the others and keeps what they set, checking versions; it reads none of it. Runs the same in a
68
+ * Durable Object (one for each room) and in `ta relay`.
69
+ */
70
+ export declare class RelayHub {
71
+ protected readonly storage: RelayHubStorage;
72
+ /** The open connections of the room. */
73
+ protected readonly sockets: () => RelayHubSocket[];
74
+ protected readonly now: () => number;
75
+ protected readonly rates: Map<unknown, {
76
+ second: number;
77
+ count: number;
78
+ }>;
79
+ constructor(storage: RelayHubStorage,
80
+ /** The open connections of the room. */
81
+ sockets: () => RelayHubSocket[], now?: () => number);
82
+ receive(socket: RelayHubSocket, text: string): Promise<void>;
83
+ /** A connection closed: the others hear that its member went, if it has no other. */
84
+ closed(socket: RelayHubSocket): void;
85
+ /** Nobody used the room for RELAY_HUB_IDLE_DAYS: it goes. */
86
+ alarm(): Promise<void>;
87
+ protected first(socket: RelayHubSocket, request: RelayHubRequest): Promise<void>;
88
+ protected create(socket: RelayHubSocket, member: string, token: string): Promise<void>;
89
+ protected auth(socket: RelayHubSocket, member: string, token: string): Promise<void>;
90
+ protected ask(socket: RelayHubSocket, request: Extract<RelayHubRequest, {
91
+ t: 'ask';
92
+ }>): Promise<void>;
93
+ protected wait(socket: RelayHubSocket, ask: string, token: string): Promise<void>;
94
+ protected answered(socket: RelayHubSocket, ask: string, pending: HubAsks[string]): Promise<void>;
95
+ protected fromMember(socket: RelayHubSocket, member: string, request: RelayHubRequest): Promise<void>;
96
+ protected forward(socket: RelayHubSocket, member: string, request: Extract<RelayHubRequest, {
97
+ t: 'send';
98
+ }>): void;
99
+ protected set(socket: RelayHubSocket, member: string, meta: HubMeta, request: Extract<RelayHubRequest, {
100
+ t: 'set';
101
+ }>): Promise<void>;
102
+ protected admit(socket: RelayHubSocket, members: HubMembers, request: Extract<RelayHubRequest, {
103
+ t: 'admit';
104
+ }>): Promise<void>;
105
+ protected setRoster(socket: RelayHubSocket, roster: RelayHubRoster): Promise<void>;
106
+ protected closeRoom(): Promise<void>;
107
+ /** The asks still waiting for the owner, those past their time dropped. */
108
+ protected asks(): Promise<HubAsks>;
109
+ protected pendingAsks(): Promise<RelayHubAsk[]>;
110
+ protected touch(meta: HubMeta, write?: boolean): Promise<void>;
111
+ /** The connections of members, of one member only with `member`. */
112
+ protected members(member?: string): (RelayHubSocket & {
113
+ who: {
114
+ member: string;
115
+ };
116
+ })[];
117
+ protected online(member: string, except: RelayHubSocket): boolean;
118
+ protected broadcast(event: RelayHubEvent, except?: RelayHubSocket): void;
119
+ protected send(socket: RelayHubSocket, event: RelayHubEvent): void;
120
+ protected refuse(socket: RelayHubSocket, code: RelayHubFailure, message: string, close: RelayHubCloseCode): void;
121
+ protected allowed(socket: RelayHubSocket): boolean;
122
+ protected static id(id: unknown): id is string;
123
+ protected static token(token: unknown): token is string;
124
+ }
125
+ export {};