@kernlize/core 0.10.0 → 0.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.
- package/dist/index.d.ts +702 -107
- package/dist/index.js +997 -171
- package/dist/index.js.map +1 -1
- package/package.json +2 -2
package/dist/index.js
CHANGED
|
@@ -251,16 +251,16 @@ function fallbackFor(fallback, purpose) {
|
|
|
251
251
|
}
|
|
252
252
|
function parseQuery(raw) {
|
|
253
253
|
const lower = raw.trim().toLowerCase();
|
|
254
|
-
const
|
|
255
|
-
return { text:
|
|
254
|
+
const text3 = lower.replace(/^wss?:\/\//, "").replace(/\/+$/, "");
|
|
255
|
+
return { text: text3, anchored: text3 !== lower.replace(/\/+$/, "") };
|
|
256
256
|
}
|
|
257
|
-
function matchScore(url,
|
|
257
|
+
function matchScore(url, query2) {
|
|
258
258
|
const address = url.replace(/^wss?:\/\//, "").replace(/\/$/, "");
|
|
259
|
-
if (!
|
|
260
|
-
if (address.startsWith(
|
|
261
|
-
if (
|
|
262
|
-
if (address.split(/[.\-/]/).some((word) => word.startsWith(
|
|
263
|
-
return address.includes(
|
|
259
|
+
if (!query2.anchored && address.replace(/^(?:relay|nostr)\./, "").startsWith(query2.text)) return 3;
|
|
260
|
+
if (address.startsWith(query2.text)) return 2;
|
|
261
|
+
if (query2.anchored) return 0;
|
|
262
|
+
if (address.split(/[.\-/]/).some((word) => word.startsWith(query2.text))) return 2;
|
|
263
|
+
return address.includes(query2.text) ? 1 : 0;
|
|
264
264
|
}
|
|
265
265
|
function createRelayDirectory(options) {
|
|
266
266
|
const now = options.now ?? (() => Math.floor(Date.now() / 1e3));
|
|
@@ -319,9 +319,9 @@ function createRelayDirectory(options) {
|
|
|
319
319
|
return {
|
|
320
320
|
listings$: listings$.asObservable(),
|
|
321
321
|
listings: () => current().listings,
|
|
322
|
-
search(
|
|
323
|
-
const
|
|
324
|
-
return current().listings.map((listing) => ({ listing, score: matchScore(listing.url,
|
|
322
|
+
search(text3, limit = 10) {
|
|
323
|
+
const query2 = parseQuery(text3);
|
|
324
|
+
return current().listings.map((listing) => ({ listing, score: matchScore(listing.url, query2) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || b.listing.monitors - a.listing.monitors || byRtt(a.listing, b.listing)).slice(0, limit).map((entry) => entry.listing);
|
|
325
325
|
},
|
|
326
326
|
suggest,
|
|
327
327
|
start() {
|
|
@@ -784,6 +784,63 @@ function createIdentityProviders(store, pool, tiers, options = {}) {
|
|
|
784
784
|
};
|
|
785
785
|
}
|
|
786
786
|
|
|
787
|
+
// src/grants/domain-capabilities.ts
|
|
788
|
+
var DOMAIN_CAPABILITIES = Object.freeze({
|
|
789
|
+
shell: [],
|
|
790
|
+
inc: [],
|
|
791
|
+
relay: ["relay:read", "relay:write"],
|
|
792
|
+
identity: ["identity:read"],
|
|
793
|
+
storage: ["state:read", "state:write"],
|
|
794
|
+
theme: ["theme:read"],
|
|
795
|
+
keys: ["keys:bind", "keys:forward"],
|
|
796
|
+
media: ["media:control"],
|
|
797
|
+
notify: ["notify:send", "notify:channel"],
|
|
798
|
+
config: ["config:read"],
|
|
799
|
+
resource: ["resource:fetch"],
|
|
800
|
+
cvm: ["cvm:call"],
|
|
801
|
+
outbox: ["outbox:read", "outbox:write"],
|
|
802
|
+
upload: ["upload:write"],
|
|
803
|
+
intent: ["intent:read", "intent:write"],
|
|
804
|
+
dm: ["dm:read", "dm:write"],
|
|
805
|
+
fs: ["fs:read", "fs:write"],
|
|
806
|
+
llm: ["llm:generate"],
|
|
807
|
+
cache: ["cache:read", "cache:write"],
|
|
808
|
+
// kehto's ACL has no capability for direct connections; the service checks the grant itself (D-042).
|
|
809
|
+
webrtc: []
|
|
810
|
+
});
|
|
811
|
+
var BASELINE_DOMAINS = Object.freeze(["shell", "inc", "theme", "storage"]);
|
|
812
|
+
function capabilitiesForDomain(domain) {
|
|
813
|
+
return DOMAIN_CAPABILITIES[domain] ?? [];
|
|
814
|
+
}
|
|
815
|
+
function capabilitiesForDomains(domains) {
|
|
816
|
+
const wanted = new Set(domains);
|
|
817
|
+
const result = [];
|
|
818
|
+
for (const [domain, capabilities] of Object.entries(DOMAIN_CAPABILITIES)) {
|
|
819
|
+
if (wanted.has(domain)) result.push(...capabilities);
|
|
820
|
+
}
|
|
821
|
+
return result;
|
|
822
|
+
}
|
|
823
|
+
|
|
824
|
+
// src/grants/message-isolation.ts
|
|
825
|
+
var MESSAGES_DOMAIN = "dm";
|
|
826
|
+
var MESSAGE_COMPANION_DOMAINS = Object.freeze(["shell", MESSAGES_DOMAIN, "identity", "theme", "storage", "config", "notify", "keys", "intent"]);
|
|
827
|
+
var WITHHELD_CAPABILITIES = Object.freeze(["intent:write"]);
|
|
828
|
+
function sealsApplet(granted) {
|
|
829
|
+
return granted.includes(MESSAGES_DOMAIN);
|
|
830
|
+
}
|
|
831
|
+
function domainsInForce(granted, baseline = BASELINE_DOMAINS) {
|
|
832
|
+
const held = [.../* @__PURE__ */ new Set([...baseline, ...granted])];
|
|
833
|
+
return Object.freeze(sealsApplet(granted) ? held.filter((domain) => MESSAGE_COMPANION_DOMAINS.includes(domain)) : held);
|
|
834
|
+
}
|
|
835
|
+
function withheldDomains(granted, baseline = BASELINE_DOMAINS) {
|
|
836
|
+
const inForce = domainsInForce(granted, baseline);
|
|
837
|
+
return Object.freeze([.../* @__PURE__ */ new Set([...baseline, ...granted])].filter((domain) => !inForce.includes(domain)));
|
|
838
|
+
}
|
|
839
|
+
function capabilitiesInForce(granted) {
|
|
840
|
+
const capabilities = capabilitiesForDomains(domainsInForce(granted));
|
|
841
|
+
return sealsApplet(granted) ? capabilities.filter((capability) => !WITHHELD_CAPABILITIES.includes(capability)) : capabilities;
|
|
842
|
+
}
|
|
843
|
+
|
|
787
844
|
// src/applesauce/accounts.ts
|
|
788
845
|
import { AccountManager } from "applesauce-accounts";
|
|
789
846
|
import { registerCommonAccountTypes } from "applesauce-accounts/accounts";
|
|
@@ -822,6 +879,29 @@ function createKernlAccounts(storage) {
|
|
|
822
879
|
return manager;
|
|
823
880
|
}
|
|
824
881
|
|
|
882
|
+
// src/applesauce/throwaway.ts
|
|
883
|
+
import { BaseAccount } from "applesauce-accounts";
|
|
884
|
+
import { getPublicKey } from "applesauce-core/helpers/keys";
|
|
885
|
+
import { PrivateKeySigner } from "applesauce-signers";
|
|
886
|
+
var THROWAWAY_IDENTITY_TYPE = "throwaway";
|
|
887
|
+
var ThrowawayIdentity = class extends BaseAccount {
|
|
888
|
+
static type = THROWAWAY_IDENTITY_TYPE;
|
|
889
|
+
/**
|
|
890
|
+
* Refuse to be written down.
|
|
891
|
+
*
|
|
892
|
+
* @throws `denied:plaintext-key-persistence`, always.
|
|
893
|
+
*/
|
|
894
|
+
toJSON() {
|
|
895
|
+
throw new Error("denied:plaintext-key-persistence");
|
|
896
|
+
}
|
|
897
|
+
};
|
|
898
|
+
function createThrowawayIdentity(name = "Just looking") {
|
|
899
|
+
const signer = new PrivateKeySigner();
|
|
900
|
+
const identity = new ThrowawayIdentity(getPublicKey(signer.key), signer);
|
|
901
|
+
identity.metadata = { name };
|
|
902
|
+
return identity;
|
|
903
|
+
}
|
|
904
|
+
|
|
825
905
|
// src/applets/pointer.ts
|
|
826
906
|
import { decodeAddressPointer, decodeEventPointer } from "applesauce-core/helpers";
|
|
827
907
|
|
|
@@ -832,12 +912,12 @@ var MANIFEST_KIND = 35129;
|
|
|
832
912
|
function builtinAddress(id) {
|
|
833
913
|
return `kernl:${id}`;
|
|
834
914
|
}
|
|
835
|
-
function decodeBuiltin(
|
|
836
|
-
const id = ADDRESS.exec(
|
|
915
|
+
function decodeBuiltin(text3) {
|
|
916
|
+
const id = ADDRESS.exec(text3)?.[1];
|
|
837
917
|
return id === void 0 ? void 0 : { kind: "builtin", id, relays: Object.freeze([]) };
|
|
838
918
|
}
|
|
839
|
-
async function sha256Hex(
|
|
840
|
-
const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(
|
|
919
|
+
async function sha256Hex(text3) {
|
|
920
|
+
const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text3));
|
|
841
921
|
return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
|
|
842
922
|
}
|
|
843
923
|
function manifestOf(applet) {
|
|
@@ -914,15 +994,15 @@ function fromBech32(input) {
|
|
|
914
994
|
return void 0;
|
|
915
995
|
}
|
|
916
996
|
function decodePointer(input) {
|
|
917
|
-
const
|
|
918
|
-
const builtin = decodeBuiltin(
|
|
997
|
+
const text3 = input.trim().replace(/^nostr:/i, "");
|
|
998
|
+
const builtin = decodeBuiltin(text3);
|
|
919
999
|
if (builtin) return builtin;
|
|
920
|
-
if (HEX_64.test(
|
|
921
|
-
const coordinate2 = COORDINATE.exec(
|
|
1000
|
+
if (HEX_64.test(text3)) return { kind: "event", id: text3, relays: Object.freeze([]) };
|
|
1001
|
+
const coordinate2 = COORDINATE.exec(text3);
|
|
922
1002
|
if (coordinate2) return fromCoordinate(coordinate2[1], coordinate2[2], coordinate2[3]);
|
|
923
|
-
const aTag = A_TAG_COORDINATE.exec(
|
|
1003
|
+
const aTag = A_TAG_COORDINATE.exec(text3);
|
|
924
1004
|
if (aTag) return fromCoordinate(aTag[2], aTag[1], aTag[3]);
|
|
925
|
-
return fromBech32((ENCODED.exec(
|
|
1005
|
+
return fromBech32((ENCODED.exec(text3)?.[0] ?? text3).toLowerCase()) ?? invalid();
|
|
926
1006
|
}
|
|
927
1007
|
|
|
928
1008
|
// src/applets/resolve.ts
|
|
@@ -1100,10 +1180,10 @@ import {
|
|
|
1100
1180
|
resolveShellEnvironment
|
|
1101
1181
|
} from "@kehto/shell";
|
|
1102
1182
|
import { createAppletCsp, renderInsertionLockScript } from "@kernlize/guard";
|
|
1103
|
-
function spliceOnce(
|
|
1104
|
-
const at =
|
|
1183
|
+
function spliceOnce(text3, find, replacement) {
|
|
1184
|
+
const at = text3.indexOf(find);
|
|
1105
1185
|
if (at === -1) throw new Error("unavailable:frame-lock");
|
|
1106
|
-
return `${
|
|
1186
|
+
return `${text3.slice(0, at)}${replacement}${text3.slice(at + find.length)}`;
|
|
1107
1187
|
}
|
|
1108
1188
|
var NESTED_CONTEXT_LOCK = Object.freeze({ nestedContextLock: true });
|
|
1109
1189
|
function assertNoFrame(html) {
|
|
@@ -1204,10 +1284,10 @@ import {
|
|
|
1204
1284
|
estimateEnvelopeSize
|
|
1205
1285
|
} from "@kernlize/guard";
|
|
1206
1286
|
function toEnvelope(data) {
|
|
1207
|
-
const
|
|
1208
|
-
const event = typeof
|
|
1287
|
+
const record2 = typeof data === "object" && data !== null ? data : {};
|
|
1288
|
+
const event = typeof record2.event === "object" && record2.event !== null ? record2.event : {};
|
|
1209
1289
|
const envelope = {
|
|
1210
|
-
type: typeof
|
|
1290
|
+
type: typeof record2.type === "string" ? record2.type : "unknown",
|
|
1211
1291
|
size: estimateEnvelopeSize(data)
|
|
1212
1292
|
};
|
|
1213
1293
|
return typeof event.kind === "number" ? { ...envelope, kind: event.kind } : envelope;
|
|
@@ -1404,41 +1484,6 @@ function createRuntimeFirewallHooks(options) {
|
|
|
1404
1484
|
};
|
|
1405
1485
|
}
|
|
1406
1486
|
|
|
1407
|
-
// src/grants/domain-capabilities.ts
|
|
1408
|
-
var DOMAIN_CAPABILITIES = Object.freeze({
|
|
1409
|
-
shell: [],
|
|
1410
|
-
inc: [],
|
|
1411
|
-
relay: ["relay:read", "relay:write"],
|
|
1412
|
-
identity: ["identity:read"],
|
|
1413
|
-
storage: ["state:read", "state:write"],
|
|
1414
|
-
theme: ["theme:read"],
|
|
1415
|
-
keys: ["keys:bind", "keys:forward"],
|
|
1416
|
-
media: ["media:control"],
|
|
1417
|
-
notify: ["notify:send", "notify:channel"],
|
|
1418
|
-
config: ["config:read"],
|
|
1419
|
-
resource: ["resource:fetch"],
|
|
1420
|
-
cvm: ["cvm:call"],
|
|
1421
|
-
outbox: ["outbox:read", "outbox:write"],
|
|
1422
|
-
upload: ["upload:write"],
|
|
1423
|
-
intent: ["intent:read", "intent:write"],
|
|
1424
|
-
dm: ["dm:read", "dm:write"],
|
|
1425
|
-
fs: ["fs:read", "fs:write"],
|
|
1426
|
-
llm: ["llm:generate"],
|
|
1427
|
-
cache: ["cache:read", "cache:write"]
|
|
1428
|
-
});
|
|
1429
|
-
var BASELINE_DOMAINS = Object.freeze(["shell", "inc", "theme", "storage"]);
|
|
1430
|
-
function capabilitiesForDomain(domain) {
|
|
1431
|
-
return DOMAIN_CAPABILITIES[domain] ?? [];
|
|
1432
|
-
}
|
|
1433
|
-
function capabilitiesForDomains(domains) {
|
|
1434
|
-
const wanted = new Set(domains);
|
|
1435
|
-
const result = [];
|
|
1436
|
-
for (const [domain, capabilities] of Object.entries(DOMAIN_CAPABILITIES)) {
|
|
1437
|
-
if (wanted.has(domain)) result.push(...capabilities);
|
|
1438
|
-
}
|
|
1439
|
-
return result;
|
|
1440
|
-
}
|
|
1441
|
-
|
|
1442
1487
|
// src/grants/grants.ts
|
|
1443
1488
|
import { Subject as Subject2 } from "rxjs";
|
|
1444
1489
|
var STORAGE_KEY2 = "grants:v1";
|
|
@@ -1453,17 +1498,18 @@ function createGrants(options) {
|
|
|
1453
1498
|
function stored(identity) {
|
|
1454
1499
|
return records.get(keyOf(identity)) ?? { dTag: identity.dTag, hash: identity.hash, domains: [], blocked: false };
|
|
1455
1500
|
}
|
|
1456
|
-
function
|
|
1501
|
+
function record2(entry) {
|
|
1457
1502
|
return {
|
|
1458
1503
|
identity: { dTag: entry.dTag, hash: entry.hash },
|
|
1459
1504
|
domains: Object.freeze([...entry.domains]),
|
|
1460
|
-
capabilities:
|
|
1505
|
+
capabilities: capabilitiesInForce(entry.domains),
|
|
1506
|
+
withheld: withheldDomains(entry.domains),
|
|
1461
1507
|
blocked: entry.blocked,
|
|
1462
1508
|
stateQuotaBytes: options.acl.getStateQuota("", entry.dTag, entry.hash)
|
|
1463
1509
|
};
|
|
1464
1510
|
}
|
|
1465
1511
|
function syncAcl(entry) {
|
|
1466
|
-
const wanted = new Set(
|
|
1512
|
+
const wanted = new Set(capabilitiesInForce(entry.domains));
|
|
1467
1513
|
const held = options.acl.getEntry("", entry.dTag, entry.hash)?.capabilities ?? [];
|
|
1468
1514
|
for (const capability of held) if (!wanted.has(capability)) options.acl.revoke("", entry.dTag, entry.hash, capability);
|
|
1469
1515
|
for (const capability of wanted) options.acl.grant("", entry.dTag, entry.hash, capability);
|
|
@@ -1475,7 +1521,7 @@ function createGrants(options) {
|
|
|
1475
1521
|
records.set(`${entry.dTag}:${entry.hash}`, entry);
|
|
1476
1522
|
persist();
|
|
1477
1523
|
syncAcl(entry);
|
|
1478
|
-
const result =
|
|
1524
|
+
const result = record2(entry);
|
|
1479
1525
|
changes$.next(result);
|
|
1480
1526
|
return result;
|
|
1481
1527
|
}
|
|
@@ -1483,10 +1529,10 @@ function createGrants(options) {
|
|
|
1483
1529
|
commit({ ...stored(identity), domains: [...domains] });
|
|
1484
1530
|
}
|
|
1485
1531
|
return {
|
|
1486
|
-
list: () => [...records.values()].map(
|
|
1532
|
+
list: () => [...records.values()].map(record2),
|
|
1487
1533
|
get: (identity) => {
|
|
1488
1534
|
const entry = records.get(keyOf(identity));
|
|
1489
|
-
return entry ?
|
|
1535
|
+
return entry ? record2(entry) : void 0;
|
|
1490
1536
|
},
|
|
1491
1537
|
ensure: (identity) => commit(stored(identity)),
|
|
1492
1538
|
allowDomain(identity, domain) {
|
|
@@ -1512,8 +1558,8 @@ function createGrants(options) {
|
|
|
1512
1558
|
}
|
|
1513
1559
|
function createEnvironmentResolver(grants) {
|
|
1514
1560
|
return (identity, available) => {
|
|
1515
|
-
const
|
|
1516
|
-
const allowed = new Set(
|
|
1561
|
+
const record2 = grants.get({ dTag: identity.dTag, hash: identity.aggregateHash });
|
|
1562
|
+
const allowed = new Set(record2?.blocked ? ["shell"] : domainsInForce(record2?.domains ?? [], grants.baselineDomains()));
|
|
1517
1563
|
return Object.freeze({
|
|
1518
1564
|
domains: Object.freeze(available.domains.filter((domain) => allowed.has(domain))),
|
|
1519
1565
|
services: Object.freeze(available.services.filter((service) => allowed.has(service)))
|
|
@@ -1673,9 +1719,9 @@ function deletion(event, applet) {
|
|
|
1673
1719
|
function vanish(event, applet) {
|
|
1674
1720
|
const services = tagValues(event, "relay");
|
|
1675
1721
|
const everywhere = services.length === 0 || services.includes(ALL_SERVICES);
|
|
1676
|
-
const lines = [{ label: "Erase", before: "Everything this
|
|
1722
|
+
const lines = [{ label: "Erase", before: "Everything this identity has published" }];
|
|
1677
1723
|
lines.push({ label: "Services asked", after: everywhere ? "Every service" : describeItems(services, serverName) });
|
|
1678
|
-
return destructive(event, applet, "Ask services to erase your
|
|
1724
|
+
return destructive(event, applet, "Ask services to erase your identity", lines);
|
|
1679
1725
|
}
|
|
1680
1726
|
var HANDLER_PREFERENCES = 31129;
|
|
1681
1727
|
function appletName(ref) {
|
|
@@ -1865,7 +1911,7 @@ import { kinds as kinds2, verifyEvent } from "applesauce-core/helpers";
|
|
|
1865
1911
|
import { lockGiftWrap, unlockGiftWrap } from "applesauce-common/helpers/gift-wrap";
|
|
1866
1912
|
import { getConversationParticipants as getConversationParticipants2 } from "applesauce-common/helpers/messages";
|
|
1867
1913
|
import { sealRumor, toRumor } from "applesauce-common/operations/gift-wrap";
|
|
1868
|
-
import { PrivateKeySigner } from "applesauce-signers";
|
|
1914
|
+
import { PrivateKeySigner as PrivateKeySigner2 } from "applesauce-signers";
|
|
1869
1915
|
|
|
1870
1916
|
// src/messaging/signer-backend.ts
|
|
1871
1917
|
import { isHexKey, unixNow as unixNow2 } from "applesauce-core/helpers";
|
|
@@ -1919,14 +1965,14 @@ function createConversationStore() {
|
|
|
1919
1965
|
const thread = threads.get(conversationId);
|
|
1920
1966
|
thread?.messages.splice(thread.messages.findIndex((entry) => entry.id === id), 1);
|
|
1921
1967
|
},
|
|
1922
|
-
conversations(
|
|
1968
|
+
conversations(query2 = {}) {
|
|
1923
1969
|
const all = [...threads].filter(([, thread]) => thread.messages.length > 0).sort(([, a], [, b]) => latest(b) - latest(a)).map(([id, thread]) => summarize2(id, thread));
|
|
1924
|
-
const result = page(all,
|
|
1970
|
+
const result = page(all, query2.cursor, query2.limit ?? DEFAULT_CONVERSATION_LIMIT);
|
|
1925
1971
|
return { conversations: result.items, ...result.cursor === void 0 ? {} : { cursor: result.cursor } };
|
|
1926
1972
|
},
|
|
1927
|
-
messages(
|
|
1928
|
-
const all = threads.get(
|
|
1929
|
-
const result = page(all,
|
|
1973
|
+
messages(query2) {
|
|
1974
|
+
const all = threads.get(query2.conversationId)?.messages ?? [];
|
|
1975
|
+
const result = page(all, query2.cursor, query2.limit ?? DEFAULT_MESSAGE_LIMIT);
|
|
1930
1976
|
return { messages: result.items, ...result.cursor === void 0 ? {} : { cursor: result.cursor } };
|
|
1931
1977
|
}
|
|
1932
1978
|
};
|
|
@@ -2041,13 +2087,13 @@ function createSignerBackend(options, format) {
|
|
|
2041
2087
|
capabilities: CAPABILITIES
|
|
2042
2088
|
};
|
|
2043
2089
|
},
|
|
2044
|
-
async conversations(
|
|
2090
|
+
async conversations(query2) {
|
|
2045
2091
|
await sync();
|
|
2046
|
-
return store.conversations(
|
|
2092
|
+
return store.conversations(query2);
|
|
2047
2093
|
},
|
|
2048
|
-
async messages(
|
|
2094
|
+
async messages(query2) {
|
|
2049
2095
|
await sync();
|
|
2050
|
-
return store.messages(
|
|
2096
|
+
return store.messages(query2);
|
|
2051
2097
|
},
|
|
2052
2098
|
async send(request) {
|
|
2053
2099
|
const current = session();
|
|
@@ -2085,7 +2131,7 @@ function createSignerBackend(options, format) {
|
|
|
2085
2131
|
// src/messaging/private-backend.ts
|
|
2086
2132
|
var WRAP_JITTER_SECONDS = 2 * 24 * 60 * 60;
|
|
2087
2133
|
async function wrapForRecipient(recipient, seal, createdAt) {
|
|
2088
|
-
const ephemeral = new
|
|
2134
|
+
const ephemeral = new PrivateKeySigner2();
|
|
2089
2135
|
const content = await ephemeral.nip44.encrypt(recipient, JSON.stringify(seal));
|
|
2090
2136
|
const jitter = Math.floor(Math.random() * WRAP_JITTER_SECONDS);
|
|
2091
2137
|
return ephemeral.signEvent({ kind: kinds2.GiftWrap, created_at: createdAt - jitter, tags: [["p", recipient]], content });
|
|
@@ -2156,9 +2202,9 @@ import { NdrRuntime } from "nostr-double-ratchet";
|
|
|
2156
2202
|
|
|
2157
2203
|
// src/messaging/ratchet-storage.ts
|
|
2158
2204
|
var CHUNK_UNITS = 16384;
|
|
2159
|
-
function chunks(
|
|
2205
|
+
function chunks(text3) {
|
|
2160
2206
|
const parts = [];
|
|
2161
|
-
for (let start = 0; start <
|
|
2207
|
+
for (let start = 0; start < text3.length; start += CHUNK_UNITS) parts.push(text3.slice(start, start + CHUNK_UNITS));
|
|
2162
2208
|
return parts;
|
|
2163
2209
|
}
|
|
2164
2210
|
function createSealedRatchetStorage(options) {
|
|
@@ -2318,13 +2364,13 @@ function createRatchetMessagesBackend(options) {
|
|
|
2318
2364
|
const self = options.selfPubkey();
|
|
2319
2365
|
return { available: usable(), ...self === void 0 ? {} : { ownerPubkey: self }, implementations: ["ndr"], capabilities: CAPABILITIES2 };
|
|
2320
2366
|
},
|
|
2321
|
-
async conversations(
|
|
2367
|
+
async conversations(query2) {
|
|
2322
2368
|
await sync();
|
|
2323
|
-
return store.conversations(
|
|
2369
|
+
return store.conversations(query2);
|
|
2324
2370
|
},
|
|
2325
|
-
async messages(
|
|
2371
|
+
async messages(query2) {
|
|
2326
2372
|
await sync();
|
|
2327
|
-
return store.messages(
|
|
2373
|
+
return store.messages(query2);
|
|
2328
2374
|
},
|
|
2329
2375
|
async send(request) {
|
|
2330
2376
|
const availability = signerAvailability(signerOf2(), "nip44");
|
|
@@ -2422,9 +2468,9 @@ function createSealedGroupStore(options, name) {
|
|
|
2422
2468
|
const loading = open();
|
|
2423
2469
|
let writes = loading;
|
|
2424
2470
|
const seal = async (entries) => {
|
|
2425
|
-
const
|
|
2471
|
+
const text3 = JSON.stringify(Object.fromEntries(entries), encode);
|
|
2426
2472
|
const parts = [];
|
|
2427
|
-
for (let start = 0; start <
|
|
2473
|
+
for (let start = 0; start < text3.length; start += SEAL_UNITS) parts.push(text3.slice(start, start + SEAL_UNITS));
|
|
2428
2474
|
storage.setItem(key, JSON.stringify(await Promise.all(parts.map((part) => nip44.encrypt(owner, part)))));
|
|
2429
2475
|
};
|
|
2430
2476
|
const write = (change) => {
|
|
@@ -2625,13 +2671,13 @@ function createGroupMessagesBackend(options) {
|
|
|
2625
2671
|
capabilities: CAPABILITIES3
|
|
2626
2672
|
};
|
|
2627
2673
|
},
|
|
2628
|
-
async conversations(
|
|
2674
|
+
async conversations(query2) {
|
|
2629
2675
|
await sync();
|
|
2630
|
-
return store.conversations(
|
|
2676
|
+
return store.conversations(query2);
|
|
2631
2677
|
},
|
|
2632
|
-
async messages(
|
|
2678
|
+
async messages(query2) {
|
|
2633
2679
|
await sync();
|
|
2634
|
-
return store.messages(
|
|
2680
|
+
return store.messages(query2);
|
|
2635
2681
|
},
|
|
2636
2682
|
async send(request) {
|
|
2637
2683
|
const live = active();
|
|
@@ -2701,8 +2747,8 @@ function labelConversations(adapter, profiles) {
|
|
|
2701
2747
|
};
|
|
2702
2748
|
return {
|
|
2703
2749
|
...adapter,
|
|
2704
|
-
async conversations(
|
|
2705
|
-
const page2 = await adapter.conversations(
|
|
2750
|
+
async conversations(query2) {
|
|
2751
|
+
const page2 = await adapter.conversations(query2);
|
|
2706
2752
|
return { ...page2, conversations: await Promise.all(page2.conversations.map(named)) };
|
|
2707
2753
|
}
|
|
2708
2754
|
};
|
|
@@ -2856,15 +2902,15 @@ function createBlossomUploader(options) {
|
|
|
2856
2902
|
var STORAGE_KEY4 = "applet-config:v1";
|
|
2857
2903
|
function createAppletConfig(options) {
|
|
2858
2904
|
const store = createNamespacedStore(options.storage, "kernl");
|
|
2859
|
-
const
|
|
2905
|
+
const read2 = () => store.getJson(STORAGE_KEY4, {});
|
|
2860
2906
|
return {
|
|
2861
2907
|
getValues(windowId) {
|
|
2862
2908
|
const applet = options.appletOf(windowId);
|
|
2863
|
-
return applet ? { ...
|
|
2909
|
+
return applet ? { ...read2()[applet.key] } : {};
|
|
2864
2910
|
},
|
|
2865
2911
|
saveValues(windowId, values) {
|
|
2866
2912
|
const applet = options.appletOf(windowId);
|
|
2867
|
-
if (applet) store.setJson(STORAGE_KEY4, { ...
|
|
2913
|
+
if (applet) store.setJson(STORAGE_KEY4, { ...read2(), [applet.key]: values });
|
|
2868
2914
|
},
|
|
2869
2915
|
openSettings(windowId, section, context) {
|
|
2870
2916
|
const applet = options.appletOf(windowId);
|
|
@@ -2874,7 +2920,7 @@ function createAppletConfig(options) {
|
|
|
2874
2920
|
}
|
|
2875
2921
|
|
|
2876
2922
|
// src/social/common-actions.ts
|
|
2877
|
-
import { getProfileContent as getProfileContent2,
|
|
2923
|
+
import { getProfileContent as getProfileContent2, unixNow as unixNow5 } from "applesauce-core/helpers";
|
|
2878
2924
|
var FOLLOWS2 = 3;
|
|
2879
2925
|
var REACTION = 7;
|
|
2880
2926
|
var REPORT = 1984;
|
|
@@ -2882,9 +2928,7 @@ var reasonOf = (error) => error instanceof Error ? error.message : String(error)
|
|
|
2882
2928
|
function followed(event) {
|
|
2883
2929
|
return (event?.tags ?? []).filter((tag) => tag[0] === "p" && typeof tag[1] === "string").map((tag) => tag[1]);
|
|
2884
2930
|
}
|
|
2885
|
-
|
|
2886
|
-
return normalizeToPubkey(value) ?? void 0;
|
|
2887
|
-
}
|
|
2931
|
+
var located = (options, value) => options.locate(value).catch(() => void 0);
|
|
2888
2932
|
async function signed(options, windowId, template) {
|
|
2889
2933
|
const signer = options.signer();
|
|
2890
2934
|
if (!signer) return { ok: false, error: "denied:read-only" };
|
|
@@ -2901,7 +2945,7 @@ async function signed(options, windowId, template) {
|
|
|
2901
2945
|
async function changeFollows(options, windowId, pubkeys, add) {
|
|
2902
2946
|
const self = options.pubkey();
|
|
2903
2947
|
if (!self) return { ok: false, error: "denied:read-only" };
|
|
2904
|
-
const targets = pubkeys.map(
|
|
2948
|
+
const targets = await Promise.all(pubkeys.map((key) => located(options, key)));
|
|
2905
2949
|
if (targets.some((key) => key === void 0)) return { ok: false, error: "invalid:pubkey" };
|
|
2906
2950
|
await options.loadFollows(self);
|
|
2907
2951
|
const previous = options.store.getReplaceable(FOLLOWS2, self);
|
|
@@ -2914,7 +2958,7 @@ async function changeFollows(options, windowId, pubkeys, add) {
|
|
|
2914
2958
|
function createCommonActions(options) {
|
|
2915
2959
|
return {
|
|
2916
2960
|
async getProfile(target) {
|
|
2917
|
-
const pubkey =
|
|
2961
|
+
const pubkey = await located(options, target);
|
|
2918
2962
|
if (!pubkey) return { ok: false, pubkey: "", error: "invalid:pubkey" };
|
|
2919
2963
|
const card = await options.profiles.settled(pubkey);
|
|
2920
2964
|
const event = options.store.getReplaceable(0, pubkey);
|
|
@@ -2937,23 +2981,76 @@ function createCommonActions(options) {
|
|
|
2937
2981
|
const tags = [["e", targetEventId], ...target ? [["p", target.pubkey], ["k", String(target.kind)]] : [], ...emoji];
|
|
2938
2982
|
return signed(options, context.windowId, { kind: REACTION, created_at: unixNow5(), tags, content: reaction });
|
|
2939
2983
|
},
|
|
2940
|
-
report(target, reason,
|
|
2984
|
+
report(target, reason, text3, context) {
|
|
2941
2985
|
const tags = target.type === "event" ? [["e", target.id, reason], ...target.pubkey ? [["p", target.pubkey]] : []] : [["p", target.pubkey, reason]];
|
|
2942
|
-
return signed(options, context.windowId, { kind: REPORT, created_at: unixNow5(), tags, content:
|
|
2986
|
+
return signed(options, context.windowId, { kind: REPORT, created_at: unixNow5(), tags, content: text3 });
|
|
2943
2987
|
}
|
|
2944
2988
|
};
|
|
2945
2989
|
}
|
|
2946
2990
|
|
|
2947
2991
|
// src/kernl-network.ts
|
|
2948
|
-
import { lastValueFrom as
|
|
2992
|
+
import { lastValueFrom as lastValueFrom8, map as map7, takeUntil as takeUntil3 } from "rxjs";
|
|
2993
|
+
|
|
2994
|
+
// src/people/person.ts
|
|
2995
|
+
import { catchError as catchError3, EMPTY as EMPTY3, lastValueFrom as lastValueFrom7, takeUntil as takeUntil2, tap, timer as timer4 } from "rxjs";
|
|
2996
|
+
import { decodePointer as decodePointer2 } from "applesauce-core/helpers";
|
|
2997
|
+
var URI_SCHEME = /^nostr:/i;
|
|
2998
|
+
var SOCKET_URL = /^wss?:\/\//i;
|
|
2999
|
+
var HEX_KEY2 = /^[0-9a-f]{64}$/;
|
|
3000
|
+
var NO_RELAYS = Object.freeze([]);
|
|
3001
|
+
function decodeOrNothing(text3) {
|
|
3002
|
+
try {
|
|
3003
|
+
return decodePointer2(text3);
|
|
3004
|
+
} catch {
|
|
3005
|
+
return void 0;
|
|
3006
|
+
}
|
|
3007
|
+
}
|
|
3008
|
+
var PERSON_HINT_TIMEOUT_MS = 8e3;
|
|
3009
|
+
var PERSON_KINDS = [0, 10002, 10050];
|
|
3010
|
+
function parsePerson(input) {
|
|
3011
|
+
const text3 = input.trim().replace(URI_SCHEME, "").toLowerCase();
|
|
3012
|
+
if (HEX_KEY2.test(text3)) return Object.freeze({ pubkey: text3, relays: NO_RELAYS });
|
|
3013
|
+
const decoded = decodeOrNothing(text3);
|
|
3014
|
+
if (decoded?.type === "npub") return Object.freeze({ pubkey: decoded.data, relays: NO_RELAYS });
|
|
3015
|
+
if (decoded?.type !== "nprofile") return void 0;
|
|
3016
|
+
const named = decoded.data.relays;
|
|
3017
|
+
return Object.freeze({ pubkey: decoded.data.pubkey, relays: Object.freeze(named.filter((url) => SOCKET_URL.test(url))) });
|
|
3018
|
+
}
|
|
3019
|
+
function createPeople(options) {
|
|
3020
|
+
const asked = /* @__PURE__ */ new Map();
|
|
3021
|
+
const ask = (person) => {
|
|
3022
|
+
const key = `${person.pubkey}:${[...person.relays].sort().join(",")}`;
|
|
3023
|
+
const known = asked.get(key);
|
|
3024
|
+
if (known) return known;
|
|
3025
|
+
const done = lastValueFrom7(
|
|
3026
|
+
options.pool.request([...person.relays], asFilters([{ kinds: PERSON_KINDS, authors: [person.pubkey] }])).pipe(
|
|
3027
|
+
takeUntil2(timer4(options.timeoutMs ?? PERSON_HINT_TIMEOUT_MS)),
|
|
3028
|
+
tap((event) => options.store.add(event)),
|
|
3029
|
+
catchError3(() => EMPTY3)
|
|
3030
|
+
),
|
|
3031
|
+
{ defaultValue: void 0 }
|
|
3032
|
+
).then(() => void 0);
|
|
3033
|
+
asked.set(key, done);
|
|
3034
|
+
return done;
|
|
3035
|
+
};
|
|
3036
|
+
return {
|
|
3037
|
+
parse: parsePerson,
|
|
3038
|
+
async locate(input) {
|
|
3039
|
+
const person = parsePerson(input);
|
|
3040
|
+
if (!person) throw new Error("invalid:person");
|
|
3041
|
+
if (person.relays.length > 0) await ask(person);
|
|
3042
|
+
return person.pubkey;
|
|
3043
|
+
}
|
|
3044
|
+
};
|
|
3045
|
+
}
|
|
2949
3046
|
|
|
2950
3047
|
// src/profiles/profiles.ts
|
|
2951
|
-
import { catchError as
|
|
3048
|
+
import { catchError as catchError4, distinctUntilChanged as distinctUntilChanged2, EMPTY as EMPTY4, endWith as endWith2, filter as filter2, firstValueFrom as firstValueFrom2, ignoreElements as ignoreElements2, map as map6, merge as merge3, Observable as Observable2, share, switchMap as switchMap4, take as take2, timer as timer5 } from "rxjs";
|
|
2952
3049
|
import { getDisplayName, getOutboxes as getOutboxes3, getProfileContent as getProfileContent3, getProfilePicture } from "applesauce-core/helpers";
|
|
2953
3050
|
var PROFILE_KIND = 0;
|
|
2954
3051
|
var MAILBOX_KIND = 10002;
|
|
2955
3052
|
var KEEP_ALIVE_MS = 6e4;
|
|
2956
|
-
var
|
|
3053
|
+
var HEX_KEY3 = /^[0-9a-f]{64}$/;
|
|
2957
3054
|
function safePicture(event) {
|
|
2958
3055
|
const picture = getProfilePicture(event);
|
|
2959
3056
|
return picture?.startsWith("https://") ? picture : void 0;
|
|
@@ -2990,7 +3087,7 @@ function createProfiles(options) {
|
|
|
2990
3087
|
return subscription;
|
|
2991
3088
|
};
|
|
2992
3089
|
const watch = (pubkey) => new Observable2((subscriber) => {
|
|
2993
|
-
const loading =
|
|
3090
|
+
const loading = HEX_KEY3.test(pubkey) ? lookup(pubkey) : void 0;
|
|
2994
3091
|
const updates = store.replaceable(PROFILE_KIND, pubkey).pipe(
|
|
2995
3092
|
map6((event) => toProfileCard(pubkey, event)),
|
|
2996
3093
|
distinctUntilChanged2((a, b) => JSON.stringify(a) === JSON.stringify(b))
|
|
@@ -2999,7 +3096,7 @@ function createProfiles(options) {
|
|
|
2999
3096
|
updates.unsubscribe();
|
|
3000
3097
|
loading?.unsubscribe();
|
|
3001
3098
|
};
|
|
3002
|
-
}).pipe(share({ resetOnRefCountZero: () =>
|
|
3099
|
+
}).pipe(share({ resetOnRefCountZero: () => timer5(keepAlive) }));
|
|
3003
3100
|
const card = (pubkey) => toProfileCard(pubkey, store.getReplaceable(PROFILE_KIND, pubkey.toLowerCase()));
|
|
3004
3101
|
const profiles = {
|
|
3005
3102
|
card$(pubkey) {
|
|
@@ -3014,10 +3111,10 @@ function createProfiles(options) {
|
|
|
3014
3111
|
card,
|
|
3015
3112
|
settled(pubkey) {
|
|
3016
3113
|
const key = pubkey.toLowerCase();
|
|
3017
|
-
if (!
|
|
3114
|
+
if (!HEX_KEY3.test(key)) return Promise.resolve(card(key));
|
|
3018
3115
|
const found = profiles.card$(key).pipe(filter2((next) => next.found));
|
|
3019
3116
|
const answered = load({ kind: PROFILE_KIND, pubkey: key, relays: [...options.lookupRelays()] }).pipe(
|
|
3020
|
-
|
|
3117
|
+
catchError4(() => EMPTY4),
|
|
3021
3118
|
ignoreElements2(),
|
|
3022
3119
|
endWith2(void 0),
|
|
3023
3120
|
map6(() => card(key))
|
|
@@ -3039,42 +3136,679 @@ function createKernlNetwork(options, parts) {
|
|
|
3039
3136
|
const mailboxes = createAccountMailboxes({
|
|
3040
3137
|
store: eventStore,
|
|
3041
3138
|
pool,
|
|
3042
|
-
pubkey$: accounts.active$.pipe(map7((account) => account?.pubkey),
|
|
3139
|
+
pubkey$: accounts.active$.pipe(map7((account) => account?.pubkey), takeUntil3(parts.destroyed$)),
|
|
3043
3140
|
lookupRelays,
|
|
3044
3141
|
signer,
|
|
3045
3142
|
directory
|
|
3046
3143
|
});
|
|
3047
3144
|
const profiles = createProfiles({ store: eventStore, load: replaceableLoader, lookupRelays });
|
|
3145
|
+
const people = createPeople({ store: eventStore, pool });
|
|
3048
3146
|
const files = createAccountFileServers({
|
|
3049
3147
|
store: eventStore,
|
|
3050
3148
|
pool,
|
|
3051
3149
|
load: replaceableLoader,
|
|
3052
|
-
pubkey$: accounts.active$.pipe(map7((account) => account?.pubkey),
|
|
3150
|
+
pubkey$: accounts.active$.pipe(map7((account) => account?.pubkey), takeUntil3(parts.destroyed$)),
|
|
3053
3151
|
pubkey: () => accounts.active?.pubkey,
|
|
3054
3152
|
lookupRelays,
|
|
3055
3153
|
outboxes: () => tiers.get().outbox,
|
|
3056
3154
|
signer
|
|
3057
3155
|
});
|
|
3058
|
-
return { eventCache, replaceableLoader, profiles, directory, mailboxes, files, signer };
|
|
3156
|
+
return { eventCache, replaceableLoader, profiles, people, directory, mailboxes, files, signer };
|
|
3059
3157
|
}
|
|
3060
3158
|
function commonActionsFor(parts, network, consent) {
|
|
3061
3159
|
const { eventStore, pool, tiers, accounts } = parts;
|
|
3062
3160
|
return createCommonActions({
|
|
3063
3161
|
store: eventStore,
|
|
3064
3162
|
profiles: network.profiles,
|
|
3163
|
+
locate: network.people.locate,
|
|
3065
3164
|
pubkey: () => accounts.active?.pubkey,
|
|
3066
3165
|
signer: network.signer,
|
|
3067
3166
|
consent,
|
|
3068
3167
|
publish: (event) => publishAccepted(pool, selectRelayTier(tiers, [{ kinds: [event.kind] }]), event),
|
|
3069
|
-
loadFollows: (pubkey) =>
|
|
3168
|
+
loadFollows: (pubkey) => lastValueFrom8(network.replaceableLoader({ kind: 3, pubkey, relays: lookupRelaysOf(tiers.get()) }), { defaultValue: void 0 }).then(
|
|
3070
3169
|
() => void 0,
|
|
3071
3170
|
() => void 0
|
|
3072
3171
|
)
|
|
3073
3172
|
});
|
|
3074
3173
|
}
|
|
3075
3174
|
|
|
3175
|
+
// src/multiplayer/remote-tools.ts
|
|
3176
|
+
import { createCvmService } from "@kehto/services";
|
|
3177
|
+
import { createNostrCvmTransport } from "@kehto/services/cvm-nostr-transport";
|
|
3178
|
+
function mergeFamilies(host, own) {
|
|
3179
|
+
const key = (family) => `${family.family}:${family.server.pubkey}`;
|
|
3180
|
+
const chosen = new Set(own.map(key));
|
|
3181
|
+
return [...host.filter((family) => !chosen.has(key(family))), ...own];
|
|
3182
|
+
}
|
|
3183
|
+
function createCvmRelayPool(pool) {
|
|
3184
|
+
return {
|
|
3185
|
+
subscribe(relays2, filter3, params) {
|
|
3186
|
+
const handle = subscribeWithEose(pool, relays2, [filter3], (item) => {
|
|
3187
|
+
if (item === "EOSE") params.oneose?.();
|
|
3188
|
+
else params.onevent?.(item);
|
|
3189
|
+
});
|
|
3190
|
+
return { close: () => handle.unsubscribe() };
|
|
3191
|
+
},
|
|
3192
|
+
async publish(relays2, event) {
|
|
3193
|
+
await publishAccepted(pool, relays2, event);
|
|
3194
|
+
}
|
|
3195
|
+
};
|
|
3196
|
+
}
|
|
3197
|
+
function createRemoteToolsService(options) {
|
|
3198
|
+
const windows = /* @__PURE__ */ new Map();
|
|
3199
|
+
let runtime;
|
|
3200
|
+
const serviceFor = (windowId) => {
|
|
3201
|
+
let service = windows.get(windowId);
|
|
3202
|
+
if (!service) {
|
|
3203
|
+
const transport = createNostrCvmTransport({
|
|
3204
|
+
pool: createCvmRelayPool(options.pool),
|
|
3205
|
+
defaultRelays: [...options.relays()],
|
|
3206
|
+
clientSecretKey: options.identities.signer(windowId).key
|
|
3207
|
+
});
|
|
3208
|
+
service = createCvmService({ transport, ...options.registry ? { registry: options.registry() } : {} });
|
|
3209
|
+
if (runtime) service.onRegistered?.(runtime);
|
|
3210
|
+
windows.set(windowId, service);
|
|
3211
|
+
}
|
|
3212
|
+
return service;
|
|
3213
|
+
};
|
|
3214
|
+
const end = (windowId) => {
|
|
3215
|
+
const service = windows.get(windowId);
|
|
3216
|
+
windows.delete(windowId);
|
|
3217
|
+
service?.onWindowDestroyed?.(windowId);
|
|
3218
|
+
service?.dispose();
|
|
3219
|
+
options.identities.release(windowId);
|
|
3220
|
+
};
|
|
3221
|
+
return {
|
|
3222
|
+
descriptor: { name: "cvm", version: "1.0.0", description: "Remote tools, each window calling under its own key" },
|
|
3223
|
+
onRegistered(context) {
|
|
3224
|
+
runtime = context;
|
|
3225
|
+
},
|
|
3226
|
+
onUnregistered() {
|
|
3227
|
+
for (const windowId of windows.keys()) end(windowId);
|
|
3228
|
+
runtime = void 0;
|
|
3229
|
+
},
|
|
3230
|
+
handleMessage(windowId, message, send) {
|
|
3231
|
+
serviceFor(windowId).handleMessage(windowId, message, send);
|
|
3232
|
+
},
|
|
3233
|
+
onWindowDestroyed: end,
|
|
3234
|
+
onPermissionRevoked: end
|
|
3235
|
+
};
|
|
3236
|
+
}
|
|
3237
|
+
|
|
3238
|
+
// src/multiplayer/window-identities.ts
|
|
3239
|
+
import { PrivateKeySigner as PrivateKeySigner3 } from "applesauce-signers";
|
|
3240
|
+
function createWindowIdentities() {
|
|
3241
|
+
const signers = /* @__PURE__ */ new Map();
|
|
3242
|
+
return {
|
|
3243
|
+
signer(windowId) {
|
|
3244
|
+
let signer = signers.get(windowId);
|
|
3245
|
+
if (!signer) {
|
|
3246
|
+
signer = new PrivateKeySigner3();
|
|
3247
|
+
signers.set(windowId, signer);
|
|
3248
|
+
}
|
|
3249
|
+
return signer;
|
|
3250
|
+
},
|
|
3251
|
+
release(windowId) {
|
|
3252
|
+
signers.get(windowId)?.key.fill(0);
|
|
3253
|
+
signers.delete(windowId);
|
|
3254
|
+
}
|
|
3255
|
+
};
|
|
3256
|
+
}
|
|
3257
|
+
|
|
3258
|
+
// src/multiplayer/settings.ts
|
|
3259
|
+
import { BehaviorSubject as BehaviorSubject7 } from "rxjs";
|
|
3260
|
+
var STORAGE_KEY5 = "multiplayer:v1";
|
|
3261
|
+
var HEX_KEY4 = /^[0-9a-f]{64}$/u;
|
|
3262
|
+
var HELPER_URL = /^(stuns?|turns?):\S+$/u;
|
|
3263
|
+
var RELAY_URL = /^wss?:\/\/\S+$/u;
|
|
3264
|
+
var text2 = (value) => typeof value === "string" && value.trim().length > 0 && value.length <= 256;
|
|
3265
|
+
function validServers(urls) {
|
|
3266
|
+
return urls.length <= 16 && urls.every((url) => typeof url === "string" && RELAY_URL.test(url));
|
|
3267
|
+
}
|
|
3268
|
+
function validHelper(helper) {
|
|
3269
|
+
return Array.isArray(helper.urls) && helper.urls.length > 0 && helper.urls.length <= 8 && helper.urls.every((url) => typeof url === "string" && HELPER_URL.test(url)) && (helper.username === void 0 || typeof helper.username === "string") && (helper.credential === void 0 || typeof helper.credential === "string");
|
|
3270
|
+
}
|
|
3271
|
+
function validFamily(family) {
|
|
3272
|
+
const { server, tools } = family;
|
|
3273
|
+
return text2(family.family) && HEX_KEY4.test(server.pubkey) && validServers(server.relays ?? []) && Array.isArray(tools) && tools.length > 0 && tools.length <= 64 && tools.every((tool) => text2(tool.name) && HEX_KEY4.test(tool.schemaHash)) && new Set(tools.map((tool) => tool.name)).size === tools.length;
|
|
3274
|
+
}
|
|
3275
|
+
function read(raw) {
|
|
3276
|
+
const families = Array.isArray(raw.families) ? raw.families.filter(validFamily).slice(0, 16) : [];
|
|
3277
|
+
return Object.freeze({
|
|
3278
|
+
...Array.isArray(raw.servers) && validServers(raw.servers) ? { servers: raw.servers } : {},
|
|
3279
|
+
...Array.isArray(raw.helpers) && raw.helpers.every(validHelper) ? { helpers: raw.helpers } : {},
|
|
3280
|
+
families
|
|
3281
|
+
});
|
|
3282
|
+
}
|
|
3283
|
+
function createMultiplayerSettings(storage) {
|
|
3284
|
+
const store = createNamespacedStore(storage, "kernl");
|
|
3285
|
+
const state$ = new BehaviorSubject7(read(store.getJson(STORAGE_KEY5, {})));
|
|
3286
|
+
const commit = (next) => {
|
|
3287
|
+
const state = read(next);
|
|
3288
|
+
store.setJson(STORAGE_KEY5, state);
|
|
3289
|
+
state$.next(state);
|
|
3290
|
+
};
|
|
3291
|
+
const without = (key) => {
|
|
3292
|
+
const { [key]: _dropped, ...rest } = state$.value;
|
|
3293
|
+
return rest;
|
|
3294
|
+
};
|
|
3295
|
+
return {
|
|
3296
|
+
state$: state$.asObservable(),
|
|
3297
|
+
state: () => state$.value,
|
|
3298
|
+
setServers(urls) {
|
|
3299
|
+
if (urls && !validServers(urls)) throw new Error("invalid:relay-url");
|
|
3300
|
+
commit(urls ? { ...state$.value, servers: [...new Set(urls)] } : without("servers"));
|
|
3301
|
+
},
|
|
3302
|
+
setHelpers(helpers) {
|
|
3303
|
+
if (helpers && !(helpers.length <= 8 && helpers.every(validHelper))) throw new Error("invalid:helper");
|
|
3304
|
+
commit(helpers ? { ...state$.value, helpers } : without("helpers"));
|
|
3305
|
+
},
|
|
3306
|
+
saveFamily(family) {
|
|
3307
|
+
if (!validFamily(family)) throw new Error("invalid:family");
|
|
3308
|
+
const others = state$.value.families.filter((saved) => saved.family !== family.family || saved.server.pubkey !== family.server.pubkey);
|
|
3309
|
+
if (others.length >= 16) throw new Error("invalid:family");
|
|
3310
|
+
commit({ ...state$.value, families: [...others, family] });
|
|
3311
|
+
},
|
|
3312
|
+
removeFamily(label, pubkey) {
|
|
3313
|
+
commit({ ...state$.value, families: state$.value.families.filter((saved) => saved.family !== label || saved.server.pubkey !== pubkey) });
|
|
3314
|
+
}
|
|
3315
|
+
};
|
|
3316
|
+
}
|
|
3317
|
+
|
|
3318
|
+
// src/multiplayer/tool-discovery.ts
|
|
3319
|
+
import { lastValueFrom as lastValueFrom9, takeUntil as takeUntil4, timer as timer6, toArray as toArray5 } from "rxjs";
|
|
3320
|
+
import { decodeEventPointer as decodeEventPointer2, verifyEvent as verifyEvent4 } from "applesauce-core/helpers";
|
|
3321
|
+
import { computeCvmToolSchemaHash } from "@kehto/services";
|
|
3322
|
+
var KIND_SERVER = 11316;
|
|
3323
|
+
var KIND_TOOLS = 11317;
|
|
3324
|
+
var KIND_RELAY_LIST = 10002;
|
|
3325
|
+
var HASH = /^[0-9a-f]{64}$/u;
|
|
3326
|
+
var MAX_BYTES = 1e6;
|
|
3327
|
+
var MAX_TOOLS = 64;
|
|
3328
|
+
var TOOL_DISCOVERY_TIMEOUT_MS = 15e3;
|
|
3329
|
+
var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
|
|
3330
|
+
function parseJson2(text3) {
|
|
3331
|
+
try {
|
|
3332
|
+
return JSON.parse(text3);
|
|
3333
|
+
} catch {
|
|
3334
|
+
return void 0;
|
|
3335
|
+
}
|
|
3336
|
+
}
|
|
3337
|
+
function parse(input) {
|
|
3338
|
+
const typed = input.trim().replace(/^nostr:/iu, "");
|
|
3339
|
+
if (HASH.test(typed.toLowerCase())) return { type: "hash", hash: typed.toLowerCase() };
|
|
3340
|
+
if (/^nevent1/iu.test(typed)) {
|
|
3341
|
+
const pointer = decodeEventPointer2(typed);
|
|
3342
|
+
if (!pointer || pointer.kind !== void 0 && pointer.kind !== KIND_SERVER && pointer.kind !== KIND_TOOLS) throw new Error("invalid:tool-reference");
|
|
3343
|
+
return { type: "event", id: pointer.id, ...pointer.author ? { author: pointer.author } : {}, relays: pointer.relays };
|
|
3344
|
+
}
|
|
3345
|
+
let url;
|
|
3346
|
+
try {
|
|
3347
|
+
url = new URL(typed.includes("://") ? typed : `https://${typed}`);
|
|
3348
|
+
} catch {
|
|
3349
|
+
throw new Error("invalid:tool-reference");
|
|
3350
|
+
}
|
|
3351
|
+
if (url.protocol !== "https:" || url.username || url.password || !url.hostname.includes(".")) throw new Error("invalid:tool-reference");
|
|
3352
|
+
return { type: "website", url: `${url.origin}/.well-known/napplet.json` };
|
|
3353
|
+
}
|
|
3354
|
+
async function query(options, relays2, filter3) {
|
|
3355
|
+
const limit = options.timeoutMs ?? TOOL_DISCOVERY_TIMEOUT_MS;
|
|
3356
|
+
const events = await lastValueFrom9(options.pool.request([...relays2], asFilters([{ ...filter3, limit: MAX_TOOLS }])).pipe(takeUntil4(timer6(limit)), toArray5()));
|
|
3357
|
+
return events.filter((event) => event.content.length <= MAX_BYTES && verifyEvent4(event)).sort((a, b) => b.created_at - a.created_at);
|
|
3358
|
+
}
|
|
3359
|
+
async function websiteProvider(url, options) {
|
|
3360
|
+
const response = await options.fetch(url, { credentials: "omit", redirect: "error", referrerPolicy: "no-referrer" }).catch(() => void 0);
|
|
3361
|
+
const body = response?.ok ? await response.text() : "";
|
|
3362
|
+
const document = body.length <= MAX_BYTES ? parseJson2(body) : void 0;
|
|
3363
|
+
const backend = record(document) && document.version === 1 ? document.backend : void 0;
|
|
3364
|
+
if (!record(backend) || typeof backend.pubkey !== "string" || !HASH.test(backend.pubkey) || !Array.isArray(backend.relays)) throw new Error("unavailable:website");
|
|
3365
|
+
return { pubkey: backend.pubkey, relays: backend.relays.filter((relay) => typeof relay === "string") };
|
|
3366
|
+
}
|
|
3367
|
+
async function inventory(event) {
|
|
3368
|
+
const payload = parseJson2(event.content);
|
|
3369
|
+
const listed = record(payload) && Array.isArray(payload.tools) ? payload.tools : [];
|
|
3370
|
+
if (listed.length === 0 || listed.length > MAX_TOOLS) throw new Error("invalid:tool-inventory");
|
|
3371
|
+
const tools = [];
|
|
3372
|
+
for (const raw of listed) {
|
|
3373
|
+
if (!record(raw) || typeof raw.name !== "string" || !raw.name || !record(raw.inputSchema) || tools.some((tool) => tool.name === raw.name)) throw new Error("invalid:tool-inventory");
|
|
3374
|
+
const schemaHash = await computeCvmToolSchemaHash({ name: raw.name, inputSchema: raw.inputSchema, ...record(raw.outputSchema) ? { outputSchema: raw.outputSchema } : {} });
|
|
3375
|
+
const tagged = event.tags.filter((tag) => tag[0] === "i" && tag[2] === raw.name);
|
|
3376
|
+
if (tagged.some((tag) => tag[1] !== schemaHash)) throw new Error("invalid:tool-inventory");
|
|
3377
|
+
tools.push({ name: raw.name, schemaHash });
|
|
3378
|
+
}
|
|
3379
|
+
return tools;
|
|
3380
|
+
}
|
|
3381
|
+
function providerRelays(lists, pubkey, found) {
|
|
3382
|
+
const listed = lists.find((list) => list.pubkey === pubkey)?.tags.filter((tag) => tag[0] === "r" && typeof tag[1] === "string") ?? [];
|
|
3383
|
+
const unmarked = listed.filter((tag) => !tag[2]);
|
|
3384
|
+
const chosen = (unmarked.length > 0 ? unmarked : listed).map((tag) => tag[1]);
|
|
3385
|
+
return chosen.length > 0 ? chosen : [...found];
|
|
3386
|
+
}
|
|
3387
|
+
async function announcements(reference, options) {
|
|
3388
|
+
if (reference.type === "website") {
|
|
3389
|
+
const provider = await websiteProvider(reference.url, options);
|
|
3390
|
+
return { events: await query(options, provider.relays, { kinds: [KIND_TOOLS], authors: [provider.pubkey] }), relays: provider.relays };
|
|
3391
|
+
}
|
|
3392
|
+
const relays2 = reference.type === "event" && reference.relays.length > 0 ? reference.relays : options.relays;
|
|
3393
|
+
if (reference.type === "hash") return { events: await query(options, relays2, { kinds: [KIND_TOOLS], "#i": [reference.hash] }), relays: relays2 };
|
|
3394
|
+
const found = await query(options, relays2, { ids: [reference.id], kinds: [KIND_SERVER, KIND_TOOLS], ...reference.author ? { authors: [reference.author] } : {} });
|
|
3395
|
+
const first = found[0];
|
|
3396
|
+
if (first?.kind === KIND_SERVER) return { events: await query(options, relays2, { kinds: [KIND_TOOLS], authors: [first.pubkey] }), relays: relays2 };
|
|
3397
|
+
return { events: found, relays: relays2 };
|
|
3398
|
+
}
|
|
3399
|
+
async function discoverToolFamilies(input, options) {
|
|
3400
|
+
const reference = parse(input);
|
|
3401
|
+
const { events, relays: relays2 } = await announcements(reference, options);
|
|
3402
|
+
const newest2 = /* @__PURE__ */ new Map();
|
|
3403
|
+
for (const event of events) if (event.kind === KIND_TOOLS && !newest2.has(event.pubkey)) newest2.set(event.pubkey, event);
|
|
3404
|
+
if (newest2.size === 0) throw new Error("unavailable:no-tools");
|
|
3405
|
+
const lists = reference.type === "website" ? [] : await query(options, relays2, { kinds: [KIND_RELAY_LIST], authors: [...newest2.keys()] });
|
|
3406
|
+
const candidates = [];
|
|
3407
|
+
for (const event of newest2.values()) {
|
|
3408
|
+
const tools = await inventory(event);
|
|
3409
|
+
if (reference.type === "hash" && !tools.some((tool) => tool.schemaHash === reference.hash)) continue;
|
|
3410
|
+
candidates.push({
|
|
3411
|
+
family: { family: `tools.${event.pubkey.slice(0, 12)}`, server: { pubkey: event.pubkey, relays: providerRelays(lists, event.pubkey, relays2) }, tools },
|
|
3412
|
+
eventId: event.id,
|
|
3413
|
+
source: `${input.trim()} \xB7 ${event.id.slice(0, 12)}`
|
|
3414
|
+
});
|
|
3415
|
+
}
|
|
3416
|
+
if (candidates.length === 0) throw new Error("unavailable:no-tools");
|
|
3417
|
+
return candidates;
|
|
3418
|
+
}
|
|
3419
|
+
|
|
3420
|
+
// src/multiplayer/direct-connections.ts
|
|
3421
|
+
import { createWebrtcService } from "@kehto/services";
|
|
3422
|
+
|
|
3423
|
+
// src/multiplayer/direct-signaling.ts
|
|
3424
|
+
import { verifyEvent as verifyEvent5 } from "applesauce-core/helpers";
|
|
3425
|
+
var DIRECT_SIGNALING_PROFILE = "soy-rtc/1";
|
|
3426
|
+
var DIRECT_SIGNAL_KIND = 25050;
|
|
3427
|
+
var DIRECT_MAX_PAYLOAD_BYTES = 16384;
|
|
3428
|
+
var MAX_SESSIONS = 4;
|
|
3429
|
+
var MAX_PEERS = 8;
|
|
3430
|
+
var HELLO_EVERY_MS = 2e3;
|
|
3431
|
+
var JOIN_PATIENCE_MS = 45e3;
|
|
3432
|
+
var GATHER_PATIENCE_MS = 8e3;
|
|
3433
|
+
var SIGNAL_LIFETIME_S = 60;
|
|
3434
|
+
var SIGNALS_PER_SECOND = 32;
|
|
3435
|
+
var MESSAGES_PER_SECOND = 240;
|
|
3436
|
+
var BYTES_PER_SECOND = 524288;
|
|
3437
|
+
var MAX_SIGNAL_CHARS = 64e3;
|
|
3438
|
+
var MAX_SDP_CHARS = 32e3;
|
|
3439
|
+
var UNSET_LIMIT = 65535;
|
|
3440
|
+
var HEX_KEY5 = /^[0-9a-f]{64}$/u;
|
|
3441
|
+
var encoder = new TextEncoder();
|
|
3442
|
+
function invalid2(message) {
|
|
3443
|
+
throw new Error(message);
|
|
3444
|
+
}
|
|
3445
|
+
function validate(request) {
|
|
3446
|
+
const { scope } = request;
|
|
3447
|
+
if (scope.type === "room") {
|
|
3448
|
+
if (typeof scope.room !== "string" || !scope.room || scope.room.length > 256) invalid2("invalid room");
|
|
3449
|
+
if (scope.peers && (scope.peers.length > MAX_PEERS || !scope.peers.every((key) => HEX_KEY5.test(key)))) invalid2("invalid peers");
|
|
3450
|
+
} else if (scope.type !== "direct" || !HEX_KEY5.test(scope.pubkey)) invalid2("invalid scope");
|
|
3451
|
+
if (request.channel !== void 0 && (!request.channel || request.channel.length > 64)) invalid2("invalid channel");
|
|
3452
|
+
if (request.protocol !== void 0 && request.protocol.length > 128) invalid2("invalid protocol");
|
|
3453
|
+
}
|
|
3454
|
+
function reliable(body) {
|
|
3455
|
+
if (body.realtime === void 0) return true;
|
|
3456
|
+
const realtime = body.realtime;
|
|
3457
|
+
return realtime?.profile === "soy-rtc/realtime-1" && realtime.ordered === true && realtime.maxRetransmits === null;
|
|
3458
|
+
}
|
|
3459
|
+
function reliableChannel(channel) {
|
|
3460
|
+
return channel.ordered && [channel.maxRetransmits, channel.maxPacketLifeTime].every((limit) => limit === null || limit === UNSET_LIMIT);
|
|
3461
|
+
}
|
|
3462
|
+
function gathered(connection) {
|
|
3463
|
+
return new Promise((resolve) => {
|
|
3464
|
+
const finish = () => {
|
|
3465
|
+
clearTimeout(timer9);
|
|
3466
|
+
connection.removeEventListener("icegatheringstatechange", changed);
|
|
3467
|
+
resolve();
|
|
3468
|
+
};
|
|
3469
|
+
const changed = () => {
|
|
3470
|
+
if (connection.iceGatheringState === "complete") finish();
|
|
3471
|
+
};
|
|
3472
|
+
const timer9 = setTimeout(finish, GATHER_PATIENCE_MS);
|
|
3473
|
+
connection.addEventListener("icegatheringstatechange", changed);
|
|
3474
|
+
changed();
|
|
3475
|
+
});
|
|
3476
|
+
}
|
|
3477
|
+
async function wireOf(namespace, self, request, channel) {
|
|
3478
|
+
const { scope } = request;
|
|
3479
|
+
const where = scope.type === "room" ? ["room", scope.room] : ["direct", ...[self, scope.pubkey].sort()];
|
|
3480
|
+
const identity = JSON.stringify([DIRECT_SIGNALING_PROFILE, namespace, where, channel, request.protocol ?? ""]);
|
|
3481
|
+
const digest = await crypto.subtle.digest("SHA-256", encoder.encode(identity));
|
|
3482
|
+
return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
|
|
3483
|
+
}
|
|
3484
|
+
function forgetStale(memory, now) {
|
|
3485
|
+
for (const [key, at] of memory) {
|
|
3486
|
+
if (now - at <= SIGNAL_LIFETIME_S * 1e3) break;
|
|
3487
|
+
memory.delete(key);
|
|
3488
|
+
}
|
|
3489
|
+
}
|
|
3490
|
+
function createDirectSignaling(options) {
|
|
3491
|
+
const signaling = new DirectSignaling(options);
|
|
3492
|
+
return {
|
|
3493
|
+
planOpen: (request) => signaling.planOpen(request),
|
|
3494
|
+
open: (request, context) => signaling.open(request, context),
|
|
3495
|
+
send: (id, payload, context) => signaling.send(id, payload, context),
|
|
3496
|
+
close: (id, reason, context) => signaling.close(signaling.sessionFor(id, context), reason),
|
|
3497
|
+
destroyWindow: () => signaling.closeAll(),
|
|
3498
|
+
revokeWindow: () => signaling.closeAll()
|
|
3499
|
+
};
|
|
3500
|
+
}
|
|
3501
|
+
var DirectSignaling = class {
|
|
3502
|
+
constructor(options) {
|
|
3503
|
+
this.options = options;
|
|
3504
|
+
this.self = options.signer.getPublicKey();
|
|
3505
|
+
}
|
|
3506
|
+
options;
|
|
3507
|
+
sessions = /* @__PURE__ */ new Map();
|
|
3508
|
+
self;
|
|
3509
|
+
planOpen(request) {
|
|
3510
|
+
validate(request);
|
|
3511
|
+
if (this.options.relays.length === 0) invalid2("signaling unavailable");
|
|
3512
|
+
const resource = request.scope.type === "room" ? `room:${request.scope.room}` : `peer:${request.scope.pubkey}`;
|
|
3513
|
+
return { signalingRelayUrls: this.options.relays, iceEndpoints: this.options.iceEndpoints, resource };
|
|
3514
|
+
}
|
|
3515
|
+
async open(request, context) {
|
|
3516
|
+
validate(request);
|
|
3517
|
+
const me = await this.self;
|
|
3518
|
+
if (this.sessions.size >= MAX_SESSIONS) invalid2("session limit reached");
|
|
3519
|
+
if (request.scope.type === "direct" && request.scope.pubkey === me) invalid2("cannot connect to self");
|
|
3520
|
+
const channel = request.channel ?? "napplet";
|
|
3521
|
+
const wire = await wireOf(this.options.namespace, me, request, channel);
|
|
3522
|
+
if ([...this.sessions.values()].some((session2) => session2.wire === wire)) invalid2("scope already open");
|
|
3523
|
+
const session = {
|
|
3524
|
+
id: crypto.randomUUID(),
|
|
3525
|
+
wire,
|
|
3526
|
+
nonce: crypto.randomUUID(),
|
|
3527
|
+
request,
|
|
3528
|
+
channel,
|
|
3529
|
+
context,
|
|
3530
|
+
peers: /* @__PURE__ */ new Map(),
|
|
3531
|
+
retired: /* @__PURE__ */ new Map(),
|
|
3532
|
+
seen: /* @__PURE__ */ new Map(),
|
|
3533
|
+
signals: { since: Date.now(), count: 0 },
|
|
3534
|
+
open: false
|
|
3535
|
+
};
|
|
3536
|
+
this.sessions.set(session.id, session);
|
|
3537
|
+
context.signal?.addEventListener("abort", () => this.close(session), { once: true });
|
|
3538
|
+
this.start(session);
|
|
3539
|
+
const { protocol } = request;
|
|
3540
|
+
return { session: { id: session.id, scope: request.scope, channel, ...protocol ? { protocol } : {}, state: "connecting" } };
|
|
3541
|
+
}
|
|
3542
|
+
send(id, payload, context) {
|
|
3543
|
+
const session = this.sessionFor(id, context);
|
|
3544
|
+
const json = JSON.stringify(payload);
|
|
3545
|
+
const size = json === void 0 ? Infinity : encoder.encode(json).length;
|
|
3546
|
+
if (size > DIRECT_MAX_PAYLOAD_BYTES) invalid2("payload is not JSON of at most 16 KiB");
|
|
3547
|
+
const channels = [...session.peers.values()].filter((peer) => peer.joined && peer.channel?.readyState === "open").map((peer) => peer.channel);
|
|
3548
|
+
if (channels.length === 0) invalid2("peer unavailable");
|
|
3549
|
+
for (const channel of channels) channel.send(json);
|
|
3550
|
+
}
|
|
3551
|
+
sessionFor(id, context) {
|
|
3552
|
+
const session = this.sessions.get(id);
|
|
3553
|
+
if (!session || session.context.windowId !== context.windowId || !this.live(session)) throw new Error("session not found");
|
|
3554
|
+
return session;
|
|
3555
|
+
}
|
|
3556
|
+
close(session, reason) {
|
|
3557
|
+
if (!this.sessions.has(session.id)) return;
|
|
3558
|
+
this.emit(session, { type: "closed", sessionId: session.id, ...reason ? { reason } : {} });
|
|
3559
|
+
this.sessions.delete(session.id);
|
|
3560
|
+
clearInterval(session.timer);
|
|
3561
|
+
session.subscription?.close();
|
|
3562
|
+
for (const peer of session.peers.values()) this.removePeer(session, peer);
|
|
3563
|
+
}
|
|
3564
|
+
closeAll() {
|
|
3565
|
+
for (const session of this.sessions.values()) this.close(session);
|
|
3566
|
+
}
|
|
3567
|
+
live(session) {
|
|
3568
|
+
return this.sessions.get(session.id) === session && !session.context.signal?.aborted;
|
|
3569
|
+
}
|
|
3570
|
+
emit(session, event) {
|
|
3571
|
+
if (this.live(session)) session.context.emit(event);
|
|
3572
|
+
}
|
|
3573
|
+
activePeer(session, peer) {
|
|
3574
|
+
return this.live(session) && session.peers.get(peer.key) === peer;
|
|
3575
|
+
}
|
|
3576
|
+
removePeer(session, peer) {
|
|
3577
|
+
if (session.peers.get(peer.key) !== peer) return;
|
|
3578
|
+
session.peers.delete(peer.key);
|
|
3579
|
+
if (peer.joined) this.emit(session, { type: "peer", sessionId: session.id, pubkey: peer.key, state: "left" });
|
|
3580
|
+
peer.channel?.close();
|
|
3581
|
+
peer.connection.close();
|
|
3582
|
+
}
|
|
3583
|
+
async publish(session, body, recipient) {
|
|
3584
|
+
const { signer } = this.options;
|
|
3585
|
+
const raw = JSON.stringify({ v: DIRECT_SIGNALING_PROFILE, wire: session.wire, nonce: session.nonce, ...body });
|
|
3586
|
+
const now = Math.floor(Date.now() / 1e3);
|
|
3587
|
+
const event = await signer.signEvent({
|
|
3588
|
+
kind: DIRECT_SIGNAL_KIND,
|
|
3589
|
+
created_at: now,
|
|
3590
|
+
content: recipient ? await signer.nip44.encrypt(recipient, raw) : raw,
|
|
3591
|
+
tags: [["d", session.wire], ["expiration", String(now + SIGNAL_LIFETIME_S)], ...recipient ? [["p", recipient]] : []]
|
|
3592
|
+
});
|
|
3593
|
+
try {
|
|
3594
|
+
await this.options.relay.publish(this.options.relays, event);
|
|
3595
|
+
} catch {
|
|
3596
|
+
}
|
|
3597
|
+
}
|
|
3598
|
+
attach(session, peer, channel) {
|
|
3599
|
+
if (!this.activePeer(session, peer) || peer.channel || channel.label !== session.channel || channel.protocol !== "" || !reliableChannel(channel)) {
|
|
3600
|
+
channel.close();
|
|
3601
|
+
return;
|
|
3602
|
+
}
|
|
3603
|
+
peer.channel = channel;
|
|
3604
|
+
channel.addEventListener("open", () => {
|
|
3605
|
+
peer.joined = true;
|
|
3606
|
+
this.emit(session, { type: "peer", sessionId: session.id, pubkey: peer.key, state: "joined" });
|
|
3607
|
+
if (session.open) return;
|
|
3608
|
+
session.open = true;
|
|
3609
|
+
this.emit(session, { type: "state", sessionId: session.id, state: "open" });
|
|
3610
|
+
});
|
|
3611
|
+
const budget = { since: Date.now(), messages: 0, bytes: 0 };
|
|
3612
|
+
channel.addEventListener("message", (event) => {
|
|
3613
|
+
if (!this.activePeer(session, peer) || typeof event.data !== "string") return;
|
|
3614
|
+
const size = encoder.encode(event.data).length;
|
|
3615
|
+
if (Date.now() - budget.since > 1e3) Object.assign(budget, { since: Date.now(), messages: 0, bytes: 0 });
|
|
3616
|
+
budget.messages += 1;
|
|
3617
|
+
budget.bytes += size;
|
|
3618
|
+
if (size > DIRECT_MAX_PAYLOAD_BYTES || budget.messages > MESSAGES_PER_SECOND || budget.bytes > BYTES_PER_SECOND) return;
|
|
3619
|
+
try {
|
|
3620
|
+
this.emit(session, { type: "message", sessionId: session.id, from: peer.key, payload: JSON.parse(event.data) });
|
|
3621
|
+
} catch {
|
|
3622
|
+
}
|
|
3623
|
+
});
|
|
3624
|
+
channel.addEventListener("close", () => this.removePeer(session, peer));
|
|
3625
|
+
}
|
|
3626
|
+
/** Run a peer's negotiation steps one at a time; a step that fails drops the peer. */
|
|
3627
|
+
queue(session, peer, step) {
|
|
3628
|
+
peer.chain = peer.chain.then(step).catch(() => this.removePeer(session, peer));
|
|
3629
|
+
}
|
|
3630
|
+
async meet(session, key, nonce) {
|
|
3631
|
+
const known = session.peers.get(key);
|
|
3632
|
+
if (known && known.nonce !== nonce) {
|
|
3633
|
+
session.retired.set(`${key}:${known.nonce}`, Date.now());
|
|
3634
|
+
this.removePeer(session, known);
|
|
3635
|
+
} else if (known) return;
|
|
3636
|
+
if (session.peers.size >= MAX_PEERS) return;
|
|
3637
|
+
const peer = { key, nonce, connection: this.options.createPeer(), started: Date.now(), joined: false, chain: Promise.resolve() };
|
|
3638
|
+
session.peers.set(key, peer);
|
|
3639
|
+
peer.connection.addEventListener("datachannel", (event) => this.attach(session, peer, event.channel));
|
|
3640
|
+
peer.connection.addEventListener("connectionstatechange", () => {
|
|
3641
|
+
if (peer.connection.connectionState === "failed" || peer.connection.connectionState === "closed") this.removePeer(session, peer);
|
|
3642
|
+
});
|
|
3643
|
+
void this.publish(session, { type: "hello" });
|
|
3644
|
+
if (await this.self < key) this.queue(session, peer, () => this.offer(session, peer));
|
|
3645
|
+
}
|
|
3646
|
+
async offer(session, peer) {
|
|
3647
|
+
this.attach(session, peer, peer.connection.createDataChannel(session.channel, { ordered: true }));
|
|
3648
|
+
await peer.connection.setLocalDescription(await peer.connection.createOffer());
|
|
3649
|
+
await gathered(peer.connection);
|
|
3650
|
+
peer.offer = peer.connection.localDescription.sdp;
|
|
3651
|
+
await this.publish(session, { type: "offer", to: peer.nonce, sdp: peer.offer }, peer.key);
|
|
3652
|
+
}
|
|
3653
|
+
async answer(session, peer, sdp) {
|
|
3654
|
+
if (!peer.answer) {
|
|
3655
|
+
await peer.connection.setRemoteDescription({ type: "offer", sdp });
|
|
3656
|
+
await peer.connection.setLocalDescription(await peer.connection.createAnswer());
|
|
3657
|
+
await gathered(peer.connection);
|
|
3658
|
+
peer.answer = peer.connection.localDescription.sdp;
|
|
3659
|
+
}
|
|
3660
|
+
await this.publish(session, { type: "answer", to: peer.nonce, sdp: peer.answer }, peer.key);
|
|
3661
|
+
}
|
|
3662
|
+
async negotiate(session, peer, body) {
|
|
3663
|
+
const me = await this.self;
|
|
3664
|
+
const sdp = body.sdp;
|
|
3665
|
+
if (body.type === "offer" && peer.key < me) this.queue(session, peer, () => this.answer(session, peer, sdp));
|
|
3666
|
+
else if (body.type === "answer" && me < peer.key && !peer.connection.remoteDescription) {
|
|
3667
|
+
this.queue(session, peer, () => peer.connection.setRemoteDescription({ type: "answer", sdp }));
|
|
3668
|
+
}
|
|
3669
|
+
}
|
|
3670
|
+
admitted(session, event, me) {
|
|
3671
|
+
const now = Date.now();
|
|
3672
|
+
forgetStale(session.seen, now);
|
|
3673
|
+
forgetStale(session.retired, now);
|
|
3674
|
+
if (now - session.signals.since > 1e3) Object.assign(session.signals, { since: now, count: 0 });
|
|
3675
|
+
session.signals.count += 1;
|
|
3676
|
+
const { scope } = session.request;
|
|
3677
|
+
const fromAllowed = scope.type === "direct" ? event.pubkey === scope.pubkey : !scope.peers || scope.peers.includes(event.pubkey);
|
|
3678
|
+
return session.signals.count <= SIGNALS_PER_SECOND && event.kind === DIRECT_SIGNAL_KIND && event.pubkey !== me && event.content.length <= MAX_SIGNAL_CHARS && Math.abs(now / 1e3 - event.created_at) <= SIGNAL_LIFETIME_S && !session.seen.has(event.id) && event.tags.some((tag) => tag[0] === "d" && tag[1] === session.wire) && fromAllowed && verifyEvent5(event);
|
|
3679
|
+
}
|
|
3680
|
+
async receive(session, event) {
|
|
3681
|
+
const me = await this.self;
|
|
3682
|
+
if (!this.live(session) || !this.admitted(session, event, me)) return;
|
|
3683
|
+
const recipient = event.tags.find((tag) => tag[0] === "p")?.[1];
|
|
3684
|
+
if (recipient !== void 0 && recipient !== me) return;
|
|
3685
|
+
session.seen.set(event.id, Date.now());
|
|
3686
|
+
const body = JSON.parse(recipient ? await this.options.signer.nip44.decrypt(event.pubkey, event.content) : event.content);
|
|
3687
|
+
const shaped = body.v === DIRECT_SIGNALING_PROFILE && body.wire === session.wire && typeof body.nonce === "string" && body.nonce.length > 0 && body.nonce.length <= 64;
|
|
3688
|
+
if (!shaped || session.retired.has(`${event.pubkey}:${body.nonce}`) || !reliable(body)) return;
|
|
3689
|
+
if (!recipient) {
|
|
3690
|
+
if (body.type === "hello") await this.meet(session, event.pubkey, body.nonce);
|
|
3691
|
+
return;
|
|
3692
|
+
}
|
|
3693
|
+
const peer = session.peers.get(event.pubkey);
|
|
3694
|
+
if (!peer || peer.nonce !== body.nonce || body.to !== session.nonce || typeof body.sdp !== "string" || body.sdp.length > MAX_SDP_CHARS) return;
|
|
3695
|
+
await this.negotiate(session, peer, body);
|
|
3696
|
+
}
|
|
3697
|
+
start(session) {
|
|
3698
|
+
const filter3 = { kinds: [DIRECT_SIGNAL_KIND], "#d": [session.wire], since: Math.floor(Date.now() / 1e3) - 10 };
|
|
3699
|
+
session.subscription = this.options.relay.subscribe(this.options.relays, [filter3], (event) => {
|
|
3700
|
+
void this.receive(session, event).catch(() => void 0);
|
|
3701
|
+
});
|
|
3702
|
+
const tick = () => {
|
|
3703
|
+
void this.publish(session, { type: "hello" });
|
|
3704
|
+
for (const peer of session.peers.values()) {
|
|
3705
|
+
if (!peer.joined && Date.now() - peer.started > JOIN_PATIENCE_MS) this.removePeer(session, peer);
|
|
3706
|
+
else if (peer.offer && !peer.connection.remoteDescription) void this.publish(session, { type: "offer", to: peer.nonce, sdp: peer.offer }, peer.key);
|
|
3707
|
+
}
|
|
3708
|
+
};
|
|
3709
|
+
tick();
|
|
3710
|
+
session.timer = setInterval(tick, HELLO_EVERY_MS);
|
|
3711
|
+
}
|
|
3712
|
+
};
|
|
3713
|
+
|
|
3714
|
+
// src/multiplayer/direct-connections.ts
|
|
3715
|
+
function directNamespace(summary) {
|
|
3716
|
+
const [, kind, ...rest] = summary.manifest.catalogId.split(":");
|
|
3717
|
+
if (rest[0] === summary.publisher) rest.shift();
|
|
3718
|
+
return `${summary.publisher}:${kind}:${rest.join(":")}`;
|
|
3719
|
+
}
|
|
3720
|
+
function describeDirectConnection(requirements, applet) {
|
|
3721
|
+
const resource = requirements.find((requirement) => requirement.category === "resource").scope.value;
|
|
3722
|
+
const scoped = (kind) => requirements.filter((requirement) => requirement.category === "network" && requirement.scope.kind === kind).map((requirement) => requirement.scope.value);
|
|
3723
|
+
const relays2 = scoped("origin").map((origin) => new URL(origin).host);
|
|
3724
|
+
const helpers = scoped("ice");
|
|
3725
|
+
const draft = { kind: DIRECT_SIGNAL_KIND, content: "", tags: [["t", "direct"]], created_at: 0, pubkey: "", id: "", sig: "" };
|
|
3726
|
+
return {
|
|
3727
|
+
title: "Connect directly to other people",
|
|
3728
|
+
severity: "direct",
|
|
3729
|
+
lines: [
|
|
3730
|
+
{ label: "With", after: resource.startsWith("room:") ? `Anyone who joins "${resource.slice(5)}" in this applet` : "One person this applet chose" },
|
|
3731
|
+
{ label: "They learn", after: "Your network address, which can show roughly where you are" },
|
|
3732
|
+
{ label: "They see", after: "Whatever this applet sends them. The shell cannot see it." },
|
|
3733
|
+
{ label: "Introduced by", after: relays2.join(", ") },
|
|
3734
|
+
...helpers.length > 0 ? [{ label: "Helped by", after: helpers.join(", ") }] : [],
|
|
3735
|
+
{ label: "They know you as", after: "A new name for this window, not your identity" }
|
|
3736
|
+
],
|
|
3737
|
+
applet,
|
|
3738
|
+
event: draft
|
|
3739
|
+
};
|
|
3740
|
+
}
|
|
3741
|
+
function signalRelayOver(pool) {
|
|
3742
|
+
return {
|
|
3743
|
+
subscribe(relays2, filters, onEvent) {
|
|
3744
|
+
const handle = subscribeWithEose(pool, [...relays2], filters, (item) => {
|
|
3745
|
+
if (item !== "EOSE") onEvent(item);
|
|
3746
|
+
});
|
|
3747
|
+
return { close: () => handle.unsubscribe() };
|
|
3748
|
+
},
|
|
3749
|
+
async publish(relays2, event) {
|
|
3750
|
+
await publishAccepted(pool, [...relays2], event);
|
|
3751
|
+
}
|
|
3752
|
+
};
|
|
3753
|
+
}
|
|
3754
|
+
function createDirectConnectionsService(options) {
|
|
3755
|
+
const windows = /* @__PURE__ */ new Map();
|
|
3756
|
+
const createPeer = options.createPeer ?? ((configuration) => new RTCPeerConnection(configuration));
|
|
3757
|
+
let runtime;
|
|
3758
|
+
const authorize = (lifetime) => async (windowId, _operation, requirements, execute, signal) => {
|
|
3759
|
+
const applet = options.appletOf(windowId);
|
|
3760
|
+
if (!applet || !options.isGranted(windowId)) return { status: "denied" };
|
|
3761
|
+
if (!await options.ask(describeDirectConnection(requirements, applet.identity))) return { status: "denied" };
|
|
3762
|
+
if (lifetime.aborted || signal?.aborted || !options.isGranted(windowId)) return { status: "cancelled" };
|
|
3763
|
+
return { status: "executed", value: await execute(lifetime) };
|
|
3764
|
+
};
|
|
3765
|
+
const windowFor = (windowId) => {
|
|
3766
|
+
let entry = windows.get(windowId);
|
|
3767
|
+
if (!entry) {
|
|
3768
|
+
const lifetime = new AbortController();
|
|
3769
|
+
const applet = options.appletOf(windowId);
|
|
3770
|
+
const helpers = options.iceServers();
|
|
3771
|
+
const configuration = { iceServers: helpers.map((server) => ({ ...server, urls: [...server.urls] })) };
|
|
3772
|
+
const service = createWebrtcService(createDirectSignaling({
|
|
3773
|
+
signer: options.identities.signer(windowId),
|
|
3774
|
+
namespace: applet ? directNamespace(applet) : "",
|
|
3775
|
+
relays: [...options.relays()],
|
|
3776
|
+
relay: signalRelayOver(options.pool),
|
|
3777
|
+
iceEndpoints: helpers.flatMap((server) => server.urls),
|
|
3778
|
+
createPeer: () => createPeer(configuration)
|
|
3779
|
+
}));
|
|
3780
|
+
service.onRegistered?.({ ...runtime, authorizeOperation: authorize(lifetime.signal) });
|
|
3781
|
+
entry = { service, lifetime };
|
|
3782
|
+
windows.set(windowId, entry);
|
|
3783
|
+
}
|
|
3784
|
+
return entry;
|
|
3785
|
+
};
|
|
3786
|
+
const end = (windowId) => {
|
|
3787
|
+
const entry = windows.get(windowId);
|
|
3788
|
+
windows.delete(windowId);
|
|
3789
|
+
entry?.lifetime.abort();
|
|
3790
|
+
entry?.service.onWindowDestroyed?.(windowId);
|
|
3791
|
+
options.identities.release(windowId);
|
|
3792
|
+
};
|
|
3793
|
+
return {
|
|
3794
|
+
descriptor: { name: "webrtc", version: "1.0.0", description: "Direct sessions between people, each window under its own key" },
|
|
3795
|
+
onRegistered(context) {
|
|
3796
|
+
runtime = context;
|
|
3797
|
+
},
|
|
3798
|
+
onUnregistered() {
|
|
3799
|
+
for (const windowId of windows.keys()) end(windowId);
|
|
3800
|
+
runtime = void 0;
|
|
3801
|
+
},
|
|
3802
|
+
handleMessage(windowId, message, send) {
|
|
3803
|
+
windowFor(windowId).service.handleMessage(windowId, message, send);
|
|
3804
|
+
},
|
|
3805
|
+
onWindowDestroyed: end,
|
|
3806
|
+
onPermissionRevoked: end
|
|
3807
|
+
};
|
|
3808
|
+
}
|
|
3809
|
+
|
|
3076
3810
|
// src/kernl-services.ts
|
|
3077
|
-
import { verifyEvent as
|
|
3811
|
+
import { verifyEvent as verifyEvent6 } from "applesauce-core/helpers";
|
|
3078
3812
|
import {
|
|
3079
3813
|
createCommonService,
|
|
3080
3814
|
createConfigService,
|
|
@@ -3089,11 +3823,26 @@ import {
|
|
|
3089
3823
|
createUploadService
|
|
3090
3824
|
} from "@kehto/services";
|
|
3091
3825
|
import { createBridgeResourceResolver } from "@kernlize/bridges";
|
|
3826
|
+
|
|
3827
|
+
// src/people/locate-recipients.ts
|
|
3828
|
+
function locateRecipients(adapter, people) {
|
|
3829
|
+
return {
|
|
3830
|
+
...adapter,
|
|
3831
|
+
async send(request) {
|
|
3832
|
+
const recipients = await Promise.all(request.recipients.map((recipient) => people.locate(recipient))).catch(() => {
|
|
3833
|
+
throw new Error("invalid:recipient");
|
|
3834
|
+
});
|
|
3835
|
+
return adapter.send({ ...request, recipients });
|
|
3836
|
+
}
|
|
3837
|
+
};
|
|
3838
|
+
}
|
|
3839
|
+
|
|
3840
|
+
// src/kernl-services.ts
|
|
3092
3841
|
function isTheme(value) {
|
|
3093
3842
|
const colors = value?.colors;
|
|
3094
3843
|
if (typeof colors !== "object" || colors === null) return false;
|
|
3095
|
-
const { background, text:
|
|
3096
|
-
return typeof background === "string" && typeof
|
|
3844
|
+
const { background, text: text3, primary } = colors;
|
|
3845
|
+
return typeof background === "string" && typeof text3 === "string" && typeof primary === "string";
|
|
3097
3846
|
}
|
|
3098
3847
|
var LINK_PROTOCOLS = Object.freeze(["https:", "mailto:"]);
|
|
3099
3848
|
function toRelayListEntry(relays2) {
|
|
@@ -3154,7 +3903,7 @@ function createOutbox(deps, identity) {
|
|
|
3154
3903
|
if (!signer?.signEvent) throw new Error("denied:read-only");
|
|
3155
3904
|
return signer.signEvent(template);
|
|
3156
3905
|
},
|
|
3157
|
-
verifyEvent: (event) =>
|
|
3906
|
+
verifyEvent: (event) => verifyEvent6(event)
|
|
3158
3907
|
});
|
|
3159
3908
|
return createOutboxService({ router: acceptAnyRelay(router) });
|
|
3160
3909
|
}
|
|
@@ -3180,9 +3929,12 @@ function gateOutboxPublish(outbox, consent) {
|
|
|
3180
3929
|
function createKernlServices(deps) {
|
|
3181
3930
|
const identity = deps.identity ?? createIdentityProviders(deps.eventStore, deps.pool, deps.tiers);
|
|
3182
3931
|
const theme = createThemeService(deps.theme ? { initialTheme: deps.theme } : {});
|
|
3183
|
-
const
|
|
3184
|
-
const dm = createDmService({ adapter: deps.profiles ? labelConversations(
|
|
3932
|
+
const located2 = deps.people ? locateRecipients(deps.messaging.composite(), deps.people) : deps.messaging.composite();
|
|
3933
|
+
const dm = createDmService({ adapter: deps.profiles ? labelConversations(located2, deps.profiles) : located2 });
|
|
3185
3934
|
const resolve = createBridgeResourceResolver(deps.bridges);
|
|
3935
|
+
const identities = deps.identities ?? createWindowIdentities();
|
|
3936
|
+
const direct = deps.directConnections;
|
|
3937
|
+
const chosen = () => deps.multiplayer?.state();
|
|
3186
3938
|
const registry = {
|
|
3187
3939
|
relay: createAppletRelayService(deps.pool, deps.tiers),
|
|
3188
3940
|
identity: createIdentityService({ getSigner: createIdentitySigner(deps.auth), ...identity }),
|
|
@@ -3202,6 +3954,21 @@ function createKernlServices(deps) {
|
|
|
3202
3954
|
}),
|
|
3203
3955
|
dm,
|
|
3204
3956
|
outbox: gateOutboxPublish(createOutbox(deps, identity), deps.consent),
|
|
3957
|
+
cvm: createRemoteToolsService({
|
|
3958
|
+
pool: deps.pool,
|
|
3959
|
+
relays: () => chosen()?.servers ?? deps.remoteTools?.relays ?? deps.tiers.get().super,
|
|
3960
|
+
identities,
|
|
3961
|
+
registry: () => mergeFamilies(deps.remoteTools?.registry ?? [], chosen()?.families ?? [])
|
|
3962
|
+
}),
|
|
3963
|
+
...direct ? {
|
|
3964
|
+
webrtc: createDirectConnectionsService({
|
|
3965
|
+
...direct,
|
|
3966
|
+
pool: deps.pool,
|
|
3967
|
+
relays: () => chosen()?.servers ?? direct.settings.relays ?? deps.tiers.get().super,
|
|
3968
|
+
identities,
|
|
3969
|
+
iceServers: () => chosen()?.helpers ?? direct.settings.iceServers ?? []
|
|
3970
|
+
})
|
|
3971
|
+
} : {},
|
|
3205
3972
|
...deps.config ? { config: createConfigService(deps.config).handler } : {},
|
|
3206
3973
|
...deps.common ? { common: createCommonService(deps.common) } : {},
|
|
3207
3974
|
...deps.uploader ? { upload: createUploadService({ uploader: deps.uploader, uploadInfo: { rails: [{ rail: "blossom", enabled: true }] } }) } : {}
|
|
@@ -3210,7 +3977,7 @@ function createKernlServices(deps) {
|
|
|
3210
3977
|
}
|
|
3211
3978
|
|
|
3212
3979
|
// src/kernl-adapter.ts
|
|
3213
|
-
import { verifyEvent as
|
|
3980
|
+
import { verifyEvent as verifyEvent7 } from "applesauce-core/helpers";
|
|
3214
3981
|
var TIERS2 = ["discovery", "apps", "outbox", "super"];
|
|
3215
3982
|
var UPLOAD_BACKEND = Object.freeze({ rails: Object.freeze(["blossom"]) });
|
|
3216
3983
|
function isTier(tier) {
|
|
@@ -3241,7 +4008,9 @@ function createShellAdapter(deps) {
|
|
|
3241
4008
|
// kehto offers the upload domain only when both the service and this backend are present; kernl's uploads are Blossom (D-033).
|
|
3242
4009
|
upload: { getUploader: () => deps.services.upload ? UPLOAD_BACKEND : null },
|
|
3243
4010
|
common: { isAvailable: () => deps.services.common !== void 0 },
|
|
3244
|
-
|
|
4011
|
+
// kehto offers direct connections only when this says so; kernl registers the service only where the page can make peer connections (D-042).
|
|
4012
|
+
webrtc: { isAvailable: () => deps.services.webrtc !== void 0 },
|
|
4013
|
+
crypto: { verifyEvent: (event) => Promise.resolve(verifyEvent7(event)) },
|
|
3245
4014
|
link: { isAvailable: () => true },
|
|
3246
4015
|
intent: { isAvailable: () => true },
|
|
3247
4016
|
services: deps.services,
|
|
@@ -3257,11 +4026,11 @@ function createShellAdapter(deps) {
|
|
|
3257
4026
|
|
|
3258
4027
|
// src/kernl-lifecycle.ts
|
|
3259
4028
|
import { originRegistry } from "@kehto/shell";
|
|
3260
|
-
function grantNarrowingReason(plan,
|
|
4029
|
+
function grantNarrowingReason(plan, record2, baseline) {
|
|
3261
4030
|
const { identity } = plan.summary;
|
|
3262
|
-
if (
|
|
3263
|
-
if (
|
|
3264
|
-
const allowed =
|
|
4031
|
+
if (record2.identity.dTag !== identity.dTag || record2.identity.hash !== identity.hash) return void 0;
|
|
4032
|
+
if (record2.blocked) return "blocked";
|
|
4033
|
+
const allowed = new Set([...baseline, ...record2.domains].filter((domain) => !record2.withheld.includes(domain)));
|
|
3265
4034
|
return plan.environment.capabilities.domains.some((domain) => !allowed.has(domain)) ? "grant-narrowed" : void 0;
|
|
3266
4035
|
}
|
|
3267
4036
|
function keyOf2(identity) {
|
|
@@ -3322,8 +4091,8 @@ function createAppletLifecycle(context) {
|
|
|
3322
4091
|
onRevoked: (windowId, reason) => context.host.onRevoked(windowId, reason)
|
|
3323
4092
|
});
|
|
3324
4093
|
handles.set(plan.windowId, handle);
|
|
3325
|
-
const narrowed = context.grants.changes$.subscribe((
|
|
3326
|
-
const reason = grantNarrowingReason(plan,
|
|
4094
|
+
const narrowed = context.grants.changes$.subscribe((record2) => {
|
|
4095
|
+
const reason = grantNarrowingReason(plan, record2, context.grants.baselineDomains());
|
|
3327
4096
|
if (!reason) return;
|
|
3328
4097
|
handle.revoked(reason);
|
|
3329
4098
|
bridge.revokeNapplet(plan.windowId, "host");
|
|
@@ -3344,7 +4113,7 @@ function createAppletLifecycle(context) {
|
|
|
3344
4113
|
}
|
|
3345
4114
|
|
|
3346
4115
|
// src/kernl.ts
|
|
3347
|
-
import { BehaviorSubject as
|
|
4116
|
+
import { BehaviorSubject as BehaviorSubject9, map as map9, of as of3, Subject as Subject4, Subscription as Subscription2, switchMap as switchMap5 } from "rxjs";
|
|
3348
4117
|
import { EventStore } from "applesauce-core";
|
|
3349
4118
|
import { RelayPool } from "applesauce-relay";
|
|
3350
4119
|
import { buildShellCapabilities, createShellBridge } from "@kehto/shell";
|
|
@@ -3355,8 +4124,8 @@ import { Subscription } from "rxjs";
|
|
|
3355
4124
|
import { createIntentService } from "@kehto/services";
|
|
3356
4125
|
|
|
3357
4126
|
// src/intents/defaults.ts
|
|
3358
|
-
import { lastValueFrom as
|
|
3359
|
-
import { verifyEvent as
|
|
4127
|
+
import { lastValueFrom as lastValueFrom10, Subject as Subject3, takeUntil as takeUntil5, timer as timer7, toArray as toArray6 } from "rxjs";
|
|
4128
|
+
import { verifyEvent as verifyEvent8 } from "applesauce-core/helpers";
|
|
3360
4129
|
|
|
3361
4130
|
// src/intents/preferences.ts
|
|
3362
4131
|
var HANDLER_PREFERENCES_KIND = 31129;
|
|
@@ -3428,7 +4197,7 @@ function preferenceRelays(tiers) {
|
|
|
3428
4197
|
function newestPerArchetype(events, pubkey) {
|
|
3429
4198
|
const newest2 = /* @__PURE__ */ new Map();
|
|
3430
4199
|
for (const event of events) {
|
|
3431
|
-
if (event.kind !== HANDLER_PREFERENCES_KIND || event.pubkey !== pubkey || !
|
|
4200
|
+
if (event.kind !== HANDLER_PREFERENCES_KIND || event.pubkey !== pubkey || !verifyEvent8(event)) continue;
|
|
3432
4201
|
const archetype = event.tags.find((tag) => tag[0] === "d")?.[1] ?? "";
|
|
3433
4202
|
const current = newest2.get(archetype);
|
|
3434
4203
|
if (archetype && (!current || event.created_at > current.created_at)) newest2.set(archetype, event);
|
|
@@ -3471,7 +4240,7 @@ function createHandlerDefaults(options) {
|
|
|
3471
4240
|
loadedFor = pubkey;
|
|
3472
4241
|
if (!pubkey) return;
|
|
3473
4242
|
const request = options.pool.request([...preferenceRelays(options.tiers)], asFilters([{ kinds: [HANDLER_PREFERENCES_KIND], authors: [pubkey] }]));
|
|
3474
|
-
const events = await
|
|
4243
|
+
const events = await lastValueFrom10(request.pipe(takeUntil5(timer7(LOAD_TIMEOUT_MS)), toArray6()), { defaultValue: [] }).catch(() => []);
|
|
3475
4244
|
for (const [archetype, event] of newestPerArchetype(events, pubkey)) {
|
|
3476
4245
|
published.set(archetype, event);
|
|
3477
4246
|
changes$.next(archetype);
|
|
@@ -3516,9 +4285,9 @@ function createIntentDelivery(options) {
|
|
|
3516
4285
|
}
|
|
3517
4286
|
|
|
3518
4287
|
// src/intents/installed.ts
|
|
3519
|
-
import { BehaviorSubject as
|
|
4288
|
+
import { BehaviorSubject as BehaviorSubject8 } from "rxjs";
|
|
3520
4289
|
import { manifestToIntentCatalogEntry } from "@kehto/services";
|
|
3521
|
-
var
|
|
4290
|
+
var STORAGE_KEY6 = "installed:v1";
|
|
3522
4291
|
function isInstalled(value) {
|
|
3523
4292
|
if (typeof value !== "object" || value === null) return false;
|
|
3524
4293
|
const row = value;
|
|
@@ -3538,10 +4307,10 @@ function toCatalogEntry2(applet) {
|
|
|
3538
4307
|
}
|
|
3539
4308
|
function createInstalledApplets(storage, now = Date.now) {
|
|
3540
4309
|
const store = createNamespacedStore(storage, "kernl");
|
|
3541
|
-
const stored = store.getJson(
|
|
3542
|
-
const changes$ = new
|
|
4310
|
+
const stored = store.getJson(STORAGE_KEY6, []);
|
|
4311
|
+
const changes$ = new BehaviorSubject8(Object.freeze(Array.isArray(stored) ? stored.filter(isInstalled) : []));
|
|
3543
4312
|
const commit = (next) => {
|
|
3544
|
-
store.setJson(
|
|
4313
|
+
store.setJson(STORAGE_KEY6, next);
|
|
3545
4314
|
changes$.next(Object.freeze([...next]));
|
|
3546
4315
|
};
|
|
3547
4316
|
return {
|
|
@@ -3733,7 +4502,7 @@ function createKernlIntents(deps) {
|
|
|
3733
4502
|
}
|
|
3734
4503
|
|
|
3735
4504
|
// src/catalog/fetch.ts
|
|
3736
|
-
import { auditTime as auditTime2, catchError as
|
|
4505
|
+
import { auditTime as auditTime2, catchError as catchError5, EMPTY as EMPTY5, from, lastValueFrom as lastValueFrom11, map as map8, merge as merge4, mergeAll, scan, share as share2, takeUntil as takeUntil6, tap as tap2, timer as timer8 } from "rxjs";
|
|
3737
4506
|
import { getSeenRelays } from "applesauce-core/helpers";
|
|
3738
4507
|
import { NAPPLET_KIND_NAMED, NAPPLET_KIND_ROOT } from "@kehto/nip/5d";
|
|
3739
4508
|
|
|
@@ -3781,11 +4550,11 @@ function hintsFor(event, relays2) {
|
|
|
3781
4550
|
function streamCatalog(pool, tiers, options = {}) {
|
|
3782
4551
|
const relays2 = catalogRelays(tiers);
|
|
3783
4552
|
const filters = asFilters(catalogFilters(options));
|
|
3784
|
-
const cached = options.cache ? from(options.cache(filters).catch(() => [])).pipe(mergeAll()) :
|
|
4553
|
+
const cached = options.cache ? from(options.cache(filters).catch(() => [])).pipe(mergeAll()) : EMPTY5;
|
|
3785
4554
|
const live = pool.request([...relays2], filters).pipe(
|
|
3786
|
-
|
|
3787
|
-
|
|
3788
|
-
|
|
4555
|
+
takeUntil6(timer8(options.timeoutMs ?? CATALOG_TIMEOUT_MS)),
|
|
4556
|
+
catchError5(() => EMPTY5),
|
|
4557
|
+
tap2((event) => options.store?.add(event))
|
|
3789
4558
|
);
|
|
3790
4559
|
const events = merge4(cached, live);
|
|
3791
4560
|
const found = events.pipe(
|
|
@@ -3797,11 +4566,11 @@ function streamCatalog(pool, tiers, options = {}) {
|
|
|
3797
4566
|
);
|
|
3798
4567
|
const listed = (state) => newestEntries(state.listed.filter(({ event }) => !isWithdrawn(event, state.withdrawn)).map(({ entry }) => entry));
|
|
3799
4568
|
const lists = found.pipe(auditTime2(options.emitMs ?? CATALOG_EMIT_MS), map8(listed), share2());
|
|
3800
|
-
const nothingYet =
|
|
4569
|
+
const nothingYet = timer8(options.settleMs ?? CATALOG_SETTLE_MS).pipe(map8(() => Object.freeze([])), takeUntil6(lists));
|
|
3801
4570
|
return merge4(nothingYet, lists);
|
|
3802
4571
|
}
|
|
3803
4572
|
async function loadCatalog(pool, tiers, options = {}) {
|
|
3804
|
-
return
|
|
4573
|
+
return lastValueFrom11(streamCatalog(pool, tiers, options), { defaultValue: Object.freeze([]) });
|
|
3805
4574
|
}
|
|
3806
4575
|
|
|
3807
4576
|
// src/kernl.ts
|
|
@@ -3881,6 +4650,37 @@ function registriesFor(options, parts) {
|
|
|
3881
4650
|
bridges: options.bridges ?? createDefaultBridges({ handoff: (uri) => host.openLink(uri), ...options.torrent ? { torrent: options.torrent } : {} })
|
|
3882
4651
|
};
|
|
3883
4652
|
}
|
|
4653
|
+
function meetingFor(options, parts) {
|
|
4654
|
+
const settings = createMultiplayerSettings(options.host.storage);
|
|
4655
|
+
const relays2 = () => settings.state().servers ?? options.remoteTools?.relays ?? parts.tiers.get().super;
|
|
4656
|
+
const multiplayer = { ...settings, discover: (input) => discoverToolFamilies(input, { pool: parts.pool, relays: relays2(), fetch: globalThis.fetch.bind(globalThis) }) };
|
|
4657
|
+
return {
|
|
4658
|
+
deps: { identities: createWindowIdentities(), remoteTools: options.remoteTools, directConnections: directConnectionsFor(options, parts.appletOf, parts.grants), multiplayer },
|
|
4659
|
+
multiplayer
|
|
4660
|
+
};
|
|
4661
|
+
}
|
|
4662
|
+
function uploaderFor(host, files, signer, identityOf) {
|
|
4663
|
+
return createBlossomUploader({
|
|
4664
|
+
servers: () => files.current(),
|
|
4665
|
+
signer,
|
|
4666
|
+
ask: (windowId, details) => askUploadConsent(host, identityOf(windowId), details)
|
|
4667
|
+
});
|
|
4668
|
+
}
|
|
4669
|
+
function directConnectionsFor(options, appletOf2, grants) {
|
|
4670
|
+
const { createPeer, ...settings } = options.directConnections ?? {};
|
|
4671
|
+
if (!createPeer && typeof RTCPeerConnection !== "function") return void 0;
|
|
4672
|
+
return {
|
|
4673
|
+
settings,
|
|
4674
|
+
...createPeer ? { createPeer } : {},
|
|
4675
|
+
appletOf: appletOf2,
|
|
4676
|
+
isGranted(windowId) {
|
|
4677
|
+
const identity = appletOf2(windowId)?.identity;
|
|
4678
|
+
const record2 = identity && grants().get(identity);
|
|
4679
|
+
return !!record2 && !record2.blocked && record2.domains.includes("webrtc");
|
|
4680
|
+
},
|
|
4681
|
+
ask: (summary) => new Promise((resolve) => options.host.presentConsent({ summary, resolve }))
|
|
4682
|
+
};
|
|
4683
|
+
}
|
|
3884
4684
|
function appletOf(handles, windowId) {
|
|
3885
4685
|
const summary = handles.get(windowId)?.summary;
|
|
3886
4686
|
return summary && { key: summary.manifest.catalogId, title: summary.title };
|
|
@@ -3908,7 +4708,7 @@ function createKernl(options) {
|
|
|
3908
4708
|
const { messaging, bridges } = registriesFor(options, { eventStore, pool, tiers, accounts });
|
|
3909
4709
|
const handles = /* @__PURE__ */ new Map();
|
|
3910
4710
|
const guardEvents$ = new Subject4();
|
|
3911
|
-
const session$ = new
|
|
4711
|
+
const session$ = new BehaviorSubject9(null);
|
|
3912
4712
|
const destroyed$ = new Subject4();
|
|
3913
4713
|
const subscriptions = new Subscription2();
|
|
3914
4714
|
let grants;
|
|
@@ -3924,12 +4724,10 @@ function createKernl(options) {
|
|
|
3924
4724
|
onRelease: (windowId) => bridge.releaseDeferred(windowId)
|
|
3925
4725
|
});
|
|
3926
4726
|
const identityOf = (windowId) => handles.get(windowId)?.summary.identity;
|
|
3927
|
-
const { eventCache, replaceableLoader, profiles, directory, mailboxes, files, signer } = createKernlNetwork(options, { eventStore, pool, tiers, accounts, destroyed$ });
|
|
3928
|
-
const lookupBefore = lookupReplaceable(eventStore, {
|
|
3929
|
-
loader: replaceableLoader,
|
|
3930
|
-
relays: () => [...tiers.get().outbox, ...tiers.get().discovery]
|
|
3931
|
-
});
|
|
4727
|
+
const { eventCache, replaceableLoader, profiles, people, directory, mailboxes, files, signer } = createKernlNetwork(options, { eventStore, pool, tiers, accounts, destroyed$ });
|
|
4728
|
+
const lookupBefore = lookupReplaceable(eventStore, { loader: replaceableLoader, relays: () => [...tiers.get().outbox, ...tiers.get().discovery] });
|
|
3932
4729
|
const consent = createSigningConsent({ host, lookupBefore, resolveApplet: identityOf, pubkey: () => accounts.active?.pubkey });
|
|
4730
|
+
const meeting = meetingFor(options, { pool, tiers, appletOf: (windowId) => handles.get(windowId)?.summary, grants: () => grants });
|
|
3933
4731
|
const services = createKernlServices({
|
|
3934
4732
|
pool,
|
|
3935
4733
|
tiers,
|
|
@@ -3940,14 +4738,12 @@ function createKernl(options) {
|
|
|
3940
4738
|
bridges,
|
|
3941
4739
|
messaging,
|
|
3942
4740
|
profiles,
|
|
4741
|
+
people,
|
|
3943
4742
|
...host.presentSettings ? { config: createAppletConfig({ storage: host.storage, appletOf: (windowId) => appletOf(handles, windowId), present: host.presentSettings.bind(host) }) } : {},
|
|
3944
|
-
common: commonActionsFor({ eventStore, pool, tiers, accounts }, { profiles, replaceableLoader, signer }, consent),
|
|
3945
|
-
uploader:
|
|
3946
|
-
servers: () => files.current(),
|
|
3947
|
-
signer,
|
|
3948
|
-
ask: (windowId, details) => askUploadConsent(host, identityOf(windowId), details)
|
|
3949
|
-
}),
|
|
4743
|
+
common: commonActionsFor({ eventStore, pool, tiers, accounts }, { profiles, people, replaceableLoader, signer }, consent),
|
|
4744
|
+
uploader: uploaderFor(host, files, signer, identityOf),
|
|
3950
4745
|
...isTheme(options.theme) ? { theme: options.theme } : {},
|
|
4746
|
+
...meeting.deps,
|
|
3951
4747
|
resolveIdentity(windowId) {
|
|
3952
4748
|
const identity = identityOf(windowId);
|
|
3953
4749
|
return identity ? { dTag: identity.dTag, aggregateHash: identity.hash } : null;
|
|
@@ -4007,8 +4803,10 @@ function createKernl(options) {
|
|
|
4007
4803
|
stream: (streamOptions) => streamCatalog(pool, tiers, { cache: eventCache.cacheRequest, store: eventStore, ...streamOptions })
|
|
4008
4804
|
},
|
|
4009
4805
|
profiles,
|
|
4806
|
+
people,
|
|
4010
4807
|
mailboxes,
|
|
4011
4808
|
files,
|
|
4809
|
+
multiplayer: meeting.multiplayer,
|
|
4012
4810
|
directory,
|
|
4013
4811
|
intents: intents.intents,
|
|
4014
4812
|
session$,
|
|
@@ -4051,8 +4849,8 @@ function wordScore(word, entry) {
|
|
|
4051
4849
|
}
|
|
4052
4850
|
return best;
|
|
4053
4851
|
}
|
|
4054
|
-
function textScore(
|
|
4055
|
-
const words =
|
|
4852
|
+
function textScore(text3, entry) {
|
|
4853
|
+
const words = text3.toLowerCase().split(/\s+/).filter(Boolean);
|
|
4056
4854
|
let total = 0;
|
|
4057
4855
|
for (const word of words) {
|
|
4058
4856
|
const score = wordScore(word, entry);
|
|
@@ -4061,16 +4859,16 @@ function textScore(text2, entry) {
|
|
|
4061
4859
|
}
|
|
4062
4860
|
return words.length === 0 ? 1 : total;
|
|
4063
4861
|
}
|
|
4064
|
-
function passesFilters(entry,
|
|
4065
|
-
if (
|
|
4066
|
-
if (
|
|
4067
|
-
return
|
|
4862
|
+
function passesFilters(entry, query2) {
|
|
4863
|
+
if (query2.topics?.some((topic) => !entry.topics.includes(topic))) return false;
|
|
4864
|
+
if (query2.available && entry.requires.some((domain) => !query2.available?.includes(domain))) return false;
|
|
4865
|
+
return query2.convention === void 0 || entry.conventions.includes(query2.convention);
|
|
4068
4866
|
}
|
|
4069
|
-
function searchCatalog(entries,
|
|
4867
|
+
function searchCatalog(entries, query2 = {}) {
|
|
4070
4868
|
const scored = [];
|
|
4071
4869
|
for (const entry of entries) {
|
|
4072
|
-
if (!passesFilters(entry,
|
|
4073
|
-
const score = textScore(
|
|
4870
|
+
if (!passesFilters(entry, query2)) continue;
|
|
4871
|
+
const score = textScore(query2.text ?? "", entry);
|
|
4074
4872
|
if (score > 0) scored.push({ entry, score });
|
|
4075
4873
|
}
|
|
4076
4874
|
scored.sort((a, b) => b.score - a.score || b.entry.publishedAt - a.entry.publishedAt);
|
|
@@ -4102,18 +4900,27 @@ export {
|
|
|
4102
4900
|
DEFAULT_RELAY_TIERS,
|
|
4103
4901
|
DEFAULT_SUGGESTIONS,
|
|
4104
4902
|
DELIVERY_RETRY,
|
|
4903
|
+
DIRECT_MAX_PAYLOAD_BYTES,
|
|
4904
|
+
DIRECT_SIGNALING_PROFILE,
|
|
4905
|
+
DIRECT_SIGNAL_KIND,
|
|
4105
4906
|
DOMAIN_CAPABILITIES,
|
|
4106
4907
|
HANDLER_PREFERENCES_KIND,
|
|
4107
4908
|
KERNL_FRAME_POLICY_META,
|
|
4108
4909
|
KernlAccountManager,
|
|
4109
4910
|
LINK_PROTOCOLS,
|
|
4110
4911
|
MANIFEST_TIMING,
|
|
4912
|
+
MESSAGES_DOMAIN,
|
|
4913
|
+
MESSAGE_COMPANION_DOMAINS,
|
|
4111
4914
|
MESSAGING_UNAVAILABLE_REASONS,
|
|
4112
4915
|
PACKAGE_NAME,
|
|
4916
|
+
PERSON_HINT_TIMEOUT_MS,
|
|
4113
4917
|
PLAINTEXT_KEY_ACCOUNT_TYPES,
|
|
4114
4918
|
RUNTIME_FIREWALL_STORAGE_KEY,
|
|
4115
4919
|
RUNTIME_OP_CLASSES,
|
|
4116
4920
|
SHELL_RELAY_OPTIONS,
|
|
4921
|
+
THROWAWAY_IDENTITY_TYPE,
|
|
4922
|
+
TOOL_DISCOVERY_TIMEOUT_MS,
|
|
4923
|
+
ThrowawayIdentity,
|
|
4117
4924
|
UNKNOWN_CURRENT_VERSION,
|
|
4118
4925
|
abbreviate,
|
|
4119
4926
|
addressOf,
|
|
@@ -4124,6 +4931,7 @@ export {
|
|
|
4124
4931
|
builtinAddress,
|
|
4125
4932
|
capabilitiesForDomain,
|
|
4126
4933
|
capabilitiesForDomains,
|
|
4934
|
+
capabilitiesInForce,
|
|
4127
4935
|
catalogIdForRef,
|
|
4128
4936
|
catalogRelays,
|
|
4129
4937
|
commonActionsFor,
|
|
@@ -4139,9 +4947,12 @@ export {
|
|
|
4139
4947
|
createColumnsLayout,
|
|
4140
4948
|
createCommonActions,
|
|
4141
4949
|
createConsentHandler,
|
|
4950
|
+
createCvmRelayPool,
|
|
4142
4951
|
createDefaultBridges,
|
|
4143
4952
|
createDefaultLayouts,
|
|
4144
4953
|
createDefaultMessaging,
|
|
4954
|
+
createDirectConnectionsService,
|
|
4955
|
+
createDirectSignaling,
|
|
4145
4956
|
createDmRelayPool,
|
|
4146
4957
|
createDwindleLayout,
|
|
4147
4958
|
createEnvironmentResolver,
|
|
@@ -4166,8 +4977,10 @@ export {
|
|
|
4166
4977
|
createLegacyMessagesBackend,
|
|
4167
4978
|
createMasterStackLayout,
|
|
4168
4979
|
createMemoryCacheAdapter,
|
|
4980
|
+
createMultiplayerSettings,
|
|
4169
4981
|
createNamespacedStore,
|
|
4170
4982
|
createOutboxRelayPool,
|
|
4983
|
+
createPeople,
|
|
4171
4984
|
createPrivateMessagesBackend,
|
|
4172
4985
|
createProfiles,
|
|
4173
4986
|
createRatchetMessagesBackend,
|
|
@@ -4175,6 +4988,7 @@ export {
|
|
|
4175
4988
|
createRelayPoolHooks,
|
|
4176
4989
|
createRelayPoolLike,
|
|
4177
4990
|
createRelayTiers,
|
|
4991
|
+
createRemoteToolsService,
|
|
4178
4992
|
createReplaceableLoader,
|
|
4179
4993
|
createRuntimeFirewallHooks,
|
|
4180
4994
|
createSealedGroupStore,
|
|
@@ -4182,13 +4996,19 @@ export {
|
|
|
4182
4996
|
createShellAdapter,
|
|
4183
4997
|
createSigningConsent,
|
|
4184
4998
|
createSqliteOpfsCacheAdapter,
|
|
4999
|
+
createThrowawayIdentity,
|
|
5000
|
+
createWindowIdentities,
|
|
4185
5001
|
createWindowManager,
|
|
4186
5002
|
decodePointer,
|
|
4187
5003
|
defaultFetchBlob,
|
|
4188
5004
|
defaultWebCacheAdapters,
|
|
4189
5005
|
describeChange,
|
|
5006
|
+
describeDirectConnection,
|
|
4190
5007
|
describeOutcome,
|
|
4191
5008
|
describeUpload,
|
|
5009
|
+
directNamespace,
|
|
5010
|
+
discoverToolFamilies,
|
|
5011
|
+
domainsInForce,
|
|
4192
5012
|
fetchManifestEvent,
|
|
4193
5013
|
fileServerTags,
|
|
4194
5014
|
fileServersFromEvent,
|
|
@@ -4203,16 +5023,19 @@ export {
|
|
|
4203
5023
|
isTheme,
|
|
4204
5024
|
labelConversations,
|
|
4205
5025
|
loadCatalog,
|
|
5026
|
+
locateRecipients,
|
|
4206
5027
|
lookupRelaysOf,
|
|
4207
5028
|
lookupReplaceable,
|
|
4208
5029
|
mailboxTags,
|
|
4209
5030
|
mailboxesFromEvent,
|
|
5031
|
+
mergeFamilies,
|
|
4210
5032
|
messagingSigner,
|
|
4211
5033
|
mountApplet,
|
|
4212
5034
|
newestEntries,
|
|
4213
5035
|
openDefaultArtifactCache,
|
|
4214
5036
|
openEventCache,
|
|
4215
5037
|
parseHandlerPreferences,
|
|
5038
|
+
parsePerson,
|
|
4216
5039
|
planMount,
|
|
4217
5040
|
popularTopics,
|
|
4218
5041
|
preferenceRelays,
|
|
@@ -4228,6 +5051,7 @@ export {
|
|
|
4228
5051
|
resolveWindow,
|
|
4229
5052
|
resourceInitFor,
|
|
4230
5053
|
runtimeFirewallRules,
|
|
5054
|
+
sealsApplet,
|
|
4231
5055
|
searchCatalog,
|
|
4232
5056
|
selectRelayTier,
|
|
4233
5057
|
signerAvailability,
|
|
@@ -4241,6 +5065,8 @@ export {
|
|
|
4241
5065
|
toProfileCard,
|
|
4242
5066
|
toRelayUrl,
|
|
4243
5067
|
toSession,
|
|
5068
|
+
validFamily,
|
|
5069
|
+
withheldDomains,
|
|
4244
5070
|
wrapAccountSigner
|
|
4245
5071
|
};
|
|
4246
5072
|
//# sourceMappingURL=index.js.map
|