@kernlize/core 0.8.0 → 0.11.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 +621 -101
- package/dist/index.js +1049 -151
- package/dist/index.js.map +1 -1
- package/package.json +19 -19
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() {
|
|
@@ -346,6 +346,10 @@ import { unixNow } from "applesauce-core/helpers";
|
|
|
346
346
|
// src/applesauce/relay-hooks.ts
|
|
347
347
|
import { normalizeRelayUrl as normalizeRelayUrl2 } from "applesauce-core/helpers";
|
|
348
348
|
import { NAPPLET_KINDS } from "@kehto/nip/5d";
|
|
349
|
+
var SHELL_RELAY_OPTIONS = Object.freeze({
|
|
350
|
+
publishRetry: Object.freeze({ count: 1, delay: 1e3 }),
|
|
351
|
+
requestReconnect: Object.freeze({ count: 1, delay: 1e3 })
|
|
352
|
+
});
|
|
349
353
|
var DISCOVERY_KINDS = /* @__PURE__ */ new Set([0, 3, 10002]);
|
|
350
354
|
var APP_KINDS = /* @__PURE__ */ new Set([...NAPPLET_KINDS, 32267]);
|
|
351
355
|
function asFilters(filters) {
|
|
@@ -591,6 +595,7 @@ function createAccountMailboxes(options) {
|
|
|
591
595
|
|
|
592
596
|
// src/applesauce/relay-backend.ts
|
|
593
597
|
import { lastValueFrom, toArray } from "rxjs";
|
|
598
|
+
import { createRelayPoolService } from "@kehto/services";
|
|
594
599
|
async function publishAccepted(pool, relays2, event) {
|
|
595
600
|
const responses = relays2.length > 0 ? await pool.publish(relays2, event) : [];
|
|
596
601
|
const accepted = responses.filter((response) => response.ok).length;
|
|
@@ -610,10 +615,37 @@ function createAppletRelayBackend(pool, tiers) {
|
|
|
610
615
|
async publish(event) {
|
|
611
616
|
await publishAccepted(pool, selectRelayTier(tiers, [{ kinds: [event.kind] }]), event);
|
|
612
617
|
},
|
|
618
|
+
async publishToRelays(relayUrls2, event) {
|
|
619
|
+
await publishAccepted(pool, [...relayUrls2], event);
|
|
620
|
+
},
|
|
613
621
|
selectRelayTier: (filters) => selectRelayTier(tiers, filters),
|
|
614
622
|
isAvailable: () => true
|
|
615
623
|
};
|
|
616
624
|
}
|
|
625
|
+
var UNCANCELLED = new AbortController().signal;
|
|
626
|
+
function kindOf(message) {
|
|
627
|
+
const kind = message.event?.kind;
|
|
628
|
+
return typeof kind === "number" ? kind : void 0;
|
|
629
|
+
}
|
|
630
|
+
function createAppletRelayService(pool, tiers) {
|
|
631
|
+
const inner = createRelayPoolService(createAppletRelayBackend(pool, tiers));
|
|
632
|
+
function planRelayOperation(windowId, message) {
|
|
633
|
+
const plan = inner.planRelayOperation(windowId, message);
|
|
634
|
+
const kind = kindOf(message);
|
|
635
|
+
const relay = message.relay;
|
|
636
|
+
const hinted = typeof relay === "string" && relay.length > 0;
|
|
637
|
+
if (plan.operation === "subscribe" || plan.operation === "query" || hinted || kind === void 0) return plan;
|
|
638
|
+
const relayUrls2 = Object.freeze([...new Set(selectRelayTier(tiers, [{ kinds: [kind] }]))]);
|
|
639
|
+
return Object.freeze({ operation: plan.operation, relayUrls: relayUrls2, localOnly: relayUrls2.length === 0 });
|
|
640
|
+
}
|
|
641
|
+
return {
|
|
642
|
+
...inner,
|
|
643
|
+
planRelayOperation,
|
|
644
|
+
handleMessage(windowId, message, send) {
|
|
645
|
+
inner.executeRelayOperation(windowId, message, planRelayOperation(windowId, message), UNCANCELLED, send);
|
|
646
|
+
}
|
|
647
|
+
};
|
|
648
|
+
}
|
|
617
649
|
function createDmRelayPool(pool, tiers) {
|
|
618
650
|
return {
|
|
619
651
|
subscribe(filters, callback, relayUrls2) {
|
|
@@ -652,20 +684,28 @@ function wrapAccountSigner(account) {
|
|
|
652
684
|
return signer;
|
|
653
685
|
}
|
|
654
686
|
function createAuthHooks(accounts, consent) {
|
|
687
|
+
const signers = /* @__PURE__ */ new WeakMap();
|
|
688
|
+
function build(account, windowId) {
|
|
689
|
+
const signer = wrapAccountSigner(account);
|
|
690
|
+
if (windowId === void 0) return signer;
|
|
691
|
+
return {
|
|
692
|
+
...signer,
|
|
693
|
+
async signEvent(template) {
|
|
694
|
+
await consent(windowId, template);
|
|
695
|
+
return account.signEvent(template);
|
|
696
|
+
}
|
|
697
|
+
};
|
|
698
|
+
}
|
|
655
699
|
return {
|
|
656
700
|
getUserPubkey: () => accounts.active?.pubkey ?? null,
|
|
657
701
|
getSigner(windowId) {
|
|
658
702
|
const account = accounts.active;
|
|
659
703
|
if (!account || isReadOnlyAccount(account)) return null;
|
|
660
|
-
const
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
await consent(windowId, template);
|
|
666
|
-
return account.signEvent(template);
|
|
667
|
-
}
|
|
668
|
-
};
|
|
704
|
+
const byWindow = signers.get(account) ?? /* @__PURE__ */ new Map();
|
|
705
|
+
signers.set(account, byWindow);
|
|
706
|
+
const signer = byWindow.get(windowId) ?? build(account, windowId);
|
|
707
|
+
byWindow.set(windowId, signer);
|
|
708
|
+
return signer;
|
|
669
709
|
}
|
|
670
710
|
};
|
|
671
711
|
}
|
|
@@ -792,12 +832,12 @@ var MANIFEST_KIND = 35129;
|
|
|
792
832
|
function builtinAddress(id) {
|
|
793
833
|
return `kernl:${id}`;
|
|
794
834
|
}
|
|
795
|
-
function decodeBuiltin(
|
|
796
|
-
const id = ADDRESS.exec(
|
|
835
|
+
function decodeBuiltin(text3) {
|
|
836
|
+
const id = ADDRESS.exec(text3)?.[1];
|
|
797
837
|
return id === void 0 ? void 0 : { kind: "builtin", id, relays: Object.freeze([]) };
|
|
798
838
|
}
|
|
799
|
-
async function sha256Hex(
|
|
800
|
-
const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(
|
|
839
|
+
async function sha256Hex(text3) {
|
|
840
|
+
const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text3));
|
|
801
841
|
return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
|
|
802
842
|
}
|
|
803
843
|
function manifestOf(applet) {
|
|
@@ -874,15 +914,15 @@ function fromBech32(input) {
|
|
|
874
914
|
return void 0;
|
|
875
915
|
}
|
|
876
916
|
function decodePointer(input) {
|
|
877
|
-
const
|
|
878
|
-
const builtin = decodeBuiltin(
|
|
917
|
+
const text3 = input.trim().replace(/^nostr:/i, "");
|
|
918
|
+
const builtin = decodeBuiltin(text3);
|
|
879
919
|
if (builtin) return builtin;
|
|
880
|
-
if (HEX_64.test(
|
|
881
|
-
const coordinate2 = COORDINATE.exec(
|
|
920
|
+
if (HEX_64.test(text3)) return { kind: "event", id: text3, relays: Object.freeze([]) };
|
|
921
|
+
const coordinate2 = COORDINATE.exec(text3);
|
|
882
922
|
if (coordinate2) return fromCoordinate(coordinate2[1], coordinate2[2], coordinate2[3]);
|
|
883
|
-
const aTag = A_TAG_COORDINATE.exec(
|
|
923
|
+
const aTag = A_TAG_COORDINATE.exec(text3);
|
|
884
924
|
if (aTag) return fromCoordinate(aTag[2], aTag[1], aTag[3]);
|
|
885
|
-
return fromBech32((ENCODED.exec(
|
|
925
|
+
return fromBech32((ENCODED.exec(text3)?.[0] ?? text3).toLowerCase()) ?? invalid();
|
|
886
926
|
}
|
|
887
927
|
|
|
888
928
|
// src/applets/resolve.ts
|
|
@@ -964,22 +1004,30 @@ function settleManifestRequest(timing) {
|
|
|
964
1004
|
const after = (messages, type, waitMs) => messages.pipe(filter((message) => message.type === type), take(1), switchMap2(() => timer2(waitMs)));
|
|
965
1005
|
return (messages) => merge2(after(messages, "EVENT", timing.settleMs), after(messages, "EOSE", timing.patienceMs)).pipe(map4(() => true));
|
|
966
1006
|
}
|
|
967
|
-
|
|
968
|
-
const
|
|
1007
|
+
function watchOpened(pool, relays2) {
|
|
1008
|
+
const relayOf = pool.relay;
|
|
1009
|
+
if (typeof relayOf !== "function") return { opened: () => true, stop: () => void 0 };
|
|
1010
|
+
let opened = false;
|
|
1011
|
+
const watching = relays2.map((url) => relayOf.call(pool, url).connected$.subscribe((connected) => void (opened ||= connected)));
|
|
1012
|
+
return { opened: () => opened, stop: () => watching.forEach((watch) => watch.unsubscribe()) };
|
|
1013
|
+
}
|
|
1014
|
+
async function askRelays(pool, relays2, filter3, waits) {
|
|
1015
|
+
const watch = watchOpened(pool, relays2);
|
|
1016
|
+
const request = pool.request(relays2, asFilters([filter3]), {
|
|
1017
|
+
complete: settleManifestRequest(waits),
|
|
1018
|
+
timeout: waits.timeoutMs,
|
|
1019
|
+
reconnect: { count: 1, delay: waits.retryDelayMs }
|
|
1020
|
+
});
|
|
969
1021
|
try {
|
|
970
1022
|
const events = await lastValueFrom3(request.pipe(toArray2()), { defaultValue: [] });
|
|
971
1023
|
const newest2 = events.reduce((best, event) => best && best.created_at >= event.created_at ? best : event, void 0);
|
|
972
|
-
return newest2 ? { newest: newest2, answered: true } : { answered:
|
|
973
|
-
} catch
|
|
974
|
-
return { answered: false,
|
|
1024
|
+
return newest2 ? { newest: newest2, answered: true, opened: true } : { answered: watch.opened(), opened: watch.opened() };
|
|
1025
|
+
} catch {
|
|
1026
|
+
return { answered: false, opened: watch.opened() };
|
|
1027
|
+
} finally {
|
|
1028
|
+
watch.stop();
|
|
975
1029
|
}
|
|
976
1030
|
}
|
|
977
|
-
async function askRelays(pool, relays2, filter3, waits) {
|
|
978
|
-
const first = await askOnce(pool, relays2, filter3, waits);
|
|
979
|
-
if (!first.refused) return first;
|
|
980
|
-
await new Promise((resolve) => setTimeout(resolve, waits.retryDelayMs));
|
|
981
|
-
return askOnce(pool, relays2, filter3, waits);
|
|
982
|
-
}
|
|
983
1031
|
async function fetchManifestEvent(pool, tiers, pointer, timing = {}) {
|
|
984
1032
|
const config = tiers.get();
|
|
985
1033
|
const first = dialable([...pointer.relays, ...config.apps]);
|
|
@@ -987,12 +1035,15 @@ async function fetchManifestEvent(pool, tiers, pointer, timing = {}) {
|
|
|
987
1035
|
const waits = { ...MANIFEST_TIMING, ...timing };
|
|
988
1036
|
const filter3 = filterFor(pointer);
|
|
989
1037
|
let answered = rounds.length === 0;
|
|
1038
|
+
let opened = rounds.length === 0;
|
|
990
1039
|
for (const relays2 of rounds) {
|
|
991
1040
|
const asked = await askRelays(pool, relays2, filter3, waits);
|
|
992
1041
|
if (asked.newest) return asked.newest;
|
|
993
1042
|
answered ||= asked.answered;
|
|
1043
|
+
opened ||= asked.opened;
|
|
994
1044
|
}
|
|
995
|
-
throw new Error(
|
|
1045
|
+
if (answered) throw new Error("unavailable:manifest");
|
|
1046
|
+
throw new Error(opened ? "unavailable:network" : "unavailable:unreachable");
|
|
996
1047
|
}
|
|
997
1048
|
async function defaultFetchBlob(sha256, servers, fetchImpl = fetch) {
|
|
998
1049
|
for (const server of servers) {
|
|
@@ -1049,10 +1100,10 @@ import {
|
|
|
1049
1100
|
resolveShellEnvironment
|
|
1050
1101
|
} from "@kehto/shell";
|
|
1051
1102
|
import { createAppletCsp, renderInsertionLockScript } from "@kernlize/guard";
|
|
1052
|
-
function spliceOnce(
|
|
1053
|
-
const at =
|
|
1103
|
+
function spliceOnce(text3, find, replacement) {
|
|
1104
|
+
const at = text3.indexOf(find);
|
|
1054
1105
|
if (at === -1) throw new Error("unavailable:frame-lock");
|
|
1055
|
-
return `${
|
|
1106
|
+
return `${text3.slice(0, at)}${replacement}${text3.slice(at + find.length)}`;
|
|
1056
1107
|
}
|
|
1057
1108
|
var NESTED_CONTEXT_LOCK = Object.freeze({ nestedContextLock: true });
|
|
1058
1109
|
function assertNoFrame(html) {
|
|
@@ -1153,10 +1204,10 @@ import {
|
|
|
1153
1204
|
estimateEnvelopeSize
|
|
1154
1205
|
} from "@kernlize/guard";
|
|
1155
1206
|
function toEnvelope(data) {
|
|
1156
|
-
const
|
|
1157
|
-
const event = typeof
|
|
1207
|
+
const record2 = typeof data === "object" && data !== null ? data : {};
|
|
1208
|
+
const event = typeof record2.event === "object" && record2.event !== null ? record2.event : {};
|
|
1158
1209
|
const envelope = {
|
|
1159
|
-
type: typeof
|
|
1210
|
+
type: typeof record2.type === "string" ? record2.type : "unknown",
|
|
1160
1211
|
size: estimateEnvelopeSize(data)
|
|
1161
1212
|
};
|
|
1162
1213
|
return typeof event.kind === "number" ? { ...envelope, kind: event.kind } : envelope;
|
|
@@ -1296,6 +1347,7 @@ function createGuardPipeline(options) {
|
|
|
1296
1347
|
}
|
|
1297
1348
|
|
|
1298
1349
|
// src/guard/runtime-rules.ts
|
|
1350
|
+
import { createFirewallState } from "@kehto/rate-limit/legacy";
|
|
1299
1351
|
import { applyNappletRules } from "@kernlize/guard";
|
|
1300
1352
|
var RUNTIME_FIREWALL_STORAGE_KEY = "kernl:firewall:v1";
|
|
1301
1353
|
var RUNTIME_OP_CLASSES = Object.freeze({
|
|
@@ -1342,11 +1394,12 @@ function toGuardEvent(event, at) {
|
|
|
1342
1394
|
}
|
|
1343
1395
|
function createRuntimeFirewallHooks(options) {
|
|
1344
1396
|
const now = options.now ?? Date.now;
|
|
1397
|
+
const legacyFirewall = createFirewallState({
|
|
1398
|
+
persist: (data) => options.storage.setItem(RUNTIME_FIREWALL_STORAGE_KEY, data),
|
|
1399
|
+
load: () => options.storage.getItem(RUNTIME_FIREWALL_STORAGE_KEY)
|
|
1400
|
+
});
|
|
1345
1401
|
return {
|
|
1346
|
-
|
|
1347
|
-
persist: (data) => options.storage.setItem(RUNTIME_FIREWALL_STORAGE_KEY, data),
|
|
1348
|
-
load: () => options.storage.getItem(RUNTIME_FIREWALL_STORAGE_KEY)
|
|
1349
|
-
},
|
|
1402
|
+
legacyFirewall,
|
|
1350
1403
|
onFirewallEvent: (event) => options.onEvent(toGuardEvent(event, now()))
|
|
1351
1404
|
};
|
|
1352
1405
|
}
|
|
@@ -1371,7 +1424,9 @@ var DOMAIN_CAPABILITIES = Object.freeze({
|
|
|
1371
1424
|
dm: ["dm:read", "dm:write"],
|
|
1372
1425
|
fs: ["fs:read", "fs:write"],
|
|
1373
1426
|
llm: ["llm:generate"],
|
|
1374
|
-
cache: ["cache:read", "cache:write"]
|
|
1427
|
+
cache: ["cache:read", "cache:write"],
|
|
1428
|
+
// kehto's ACL has no capability for direct connections; the service checks the grant itself (D-042).
|
|
1429
|
+
webrtc: []
|
|
1375
1430
|
});
|
|
1376
1431
|
var BASELINE_DOMAINS = Object.freeze(["shell", "inc", "theme", "storage"]);
|
|
1377
1432
|
function capabilitiesForDomain(domain) {
|
|
@@ -1400,7 +1455,7 @@ function createGrants(options) {
|
|
|
1400
1455
|
function stored(identity) {
|
|
1401
1456
|
return records.get(keyOf(identity)) ?? { dTag: identity.dTag, hash: identity.hash, domains: [], blocked: false };
|
|
1402
1457
|
}
|
|
1403
|
-
function
|
|
1458
|
+
function record2(entry) {
|
|
1404
1459
|
return {
|
|
1405
1460
|
identity: { dTag: entry.dTag, hash: entry.hash },
|
|
1406
1461
|
domains: Object.freeze([...entry.domains]),
|
|
@@ -1422,7 +1477,7 @@ function createGrants(options) {
|
|
|
1422
1477
|
records.set(`${entry.dTag}:${entry.hash}`, entry);
|
|
1423
1478
|
persist();
|
|
1424
1479
|
syncAcl(entry);
|
|
1425
|
-
const result =
|
|
1480
|
+
const result = record2(entry);
|
|
1426
1481
|
changes$.next(result);
|
|
1427
1482
|
return result;
|
|
1428
1483
|
}
|
|
@@ -1430,10 +1485,10 @@ function createGrants(options) {
|
|
|
1430
1485
|
commit({ ...stored(identity), domains: [...domains] });
|
|
1431
1486
|
}
|
|
1432
1487
|
return {
|
|
1433
|
-
list: () => [...records.values()].map(
|
|
1488
|
+
list: () => [...records.values()].map(record2),
|
|
1434
1489
|
get: (identity) => {
|
|
1435
1490
|
const entry = records.get(keyOf(identity));
|
|
1436
|
-
return entry ?
|
|
1491
|
+
return entry ? record2(entry) : void 0;
|
|
1437
1492
|
},
|
|
1438
1493
|
ensure: (identity) => commit(stored(identity)),
|
|
1439
1494
|
allowDomain(identity, domain) {
|
|
@@ -1459,8 +1514,8 @@ function createGrants(options) {
|
|
|
1459
1514
|
}
|
|
1460
1515
|
function createEnvironmentResolver(grants) {
|
|
1461
1516
|
return (identity, available) => {
|
|
1462
|
-
const
|
|
1463
|
-
const allowed = new Set(
|
|
1517
|
+
const record2 = grants.get({ dTag: identity.dTag, hash: identity.aggregateHash });
|
|
1518
|
+
const allowed = new Set(record2?.blocked ? ["shell"] : [...grants.baselineDomains(), ...record2?.domains ?? []]);
|
|
1464
1519
|
return Object.freeze({
|
|
1465
1520
|
domains: Object.freeze(available.domains.filter((domain) => allowed.has(domain))),
|
|
1466
1521
|
services: Object.freeze(available.services.filter((service) => allowed.has(service)))
|
|
@@ -1866,14 +1921,14 @@ function createConversationStore() {
|
|
|
1866
1921
|
const thread = threads.get(conversationId);
|
|
1867
1922
|
thread?.messages.splice(thread.messages.findIndex((entry) => entry.id === id), 1);
|
|
1868
1923
|
},
|
|
1869
|
-
conversations(
|
|
1924
|
+
conversations(query2 = {}) {
|
|
1870
1925
|
const all = [...threads].filter(([, thread]) => thread.messages.length > 0).sort(([, a], [, b]) => latest(b) - latest(a)).map(([id, thread]) => summarize2(id, thread));
|
|
1871
|
-
const result = page(all,
|
|
1926
|
+
const result = page(all, query2.cursor, query2.limit ?? DEFAULT_CONVERSATION_LIMIT);
|
|
1872
1927
|
return { conversations: result.items, ...result.cursor === void 0 ? {} : { cursor: result.cursor } };
|
|
1873
1928
|
},
|
|
1874
|
-
messages(
|
|
1875
|
-
const all = threads.get(
|
|
1876
|
-
const result = page(all,
|
|
1929
|
+
messages(query2) {
|
|
1930
|
+
const all = threads.get(query2.conversationId)?.messages ?? [];
|
|
1931
|
+
const result = page(all, query2.cursor, query2.limit ?? DEFAULT_MESSAGE_LIMIT);
|
|
1877
1932
|
return { messages: result.items, ...result.cursor === void 0 ? {} : { cursor: result.cursor } };
|
|
1878
1933
|
}
|
|
1879
1934
|
};
|
|
@@ -1988,13 +2043,13 @@ function createSignerBackend(options, format) {
|
|
|
1988
2043
|
capabilities: CAPABILITIES
|
|
1989
2044
|
};
|
|
1990
2045
|
},
|
|
1991
|
-
async conversations(
|
|
2046
|
+
async conversations(query2) {
|
|
1992
2047
|
await sync();
|
|
1993
|
-
return store.conversations(
|
|
2048
|
+
return store.conversations(query2);
|
|
1994
2049
|
},
|
|
1995
|
-
async messages(
|
|
2050
|
+
async messages(query2) {
|
|
1996
2051
|
await sync();
|
|
1997
|
-
return store.messages(
|
|
2052
|
+
return store.messages(query2);
|
|
1998
2053
|
},
|
|
1999
2054
|
async send(request) {
|
|
2000
2055
|
const current = session();
|
|
@@ -2103,9 +2158,9 @@ import { NdrRuntime } from "nostr-double-ratchet";
|
|
|
2103
2158
|
|
|
2104
2159
|
// src/messaging/ratchet-storage.ts
|
|
2105
2160
|
var CHUNK_UNITS = 16384;
|
|
2106
|
-
function chunks(
|
|
2161
|
+
function chunks(text3) {
|
|
2107
2162
|
const parts = [];
|
|
2108
|
-
for (let start = 0; start <
|
|
2163
|
+
for (let start = 0; start < text3.length; start += CHUNK_UNITS) parts.push(text3.slice(start, start + CHUNK_UNITS));
|
|
2109
2164
|
return parts;
|
|
2110
2165
|
}
|
|
2111
2166
|
function createSealedRatchetStorage(options) {
|
|
@@ -2189,10 +2244,10 @@ function transportFor(options, signer) {
|
|
|
2189
2244
|
return () => handle.unsubscribe();
|
|
2190
2245
|
},
|
|
2191
2246
|
async nostrPublish(event) {
|
|
2192
|
-
const
|
|
2193
|
-
const results = await options.pool.publish(relays2(),
|
|
2247
|
+
const signed2 = await sign(event);
|
|
2248
|
+
const results = await options.pool.publish(relays2(), signed2).catch(() => []);
|
|
2194
2249
|
if (!results.some((result) => result.ok)) throw new Error("unavailable:offline");
|
|
2195
|
-
return
|
|
2250
|
+
return signed2;
|
|
2196
2251
|
}
|
|
2197
2252
|
};
|
|
2198
2253
|
}
|
|
@@ -2265,13 +2320,13 @@ function createRatchetMessagesBackend(options) {
|
|
|
2265
2320
|
const self = options.selfPubkey();
|
|
2266
2321
|
return { available: usable(), ...self === void 0 ? {} : { ownerPubkey: self }, implementations: ["ndr"], capabilities: CAPABILITIES2 };
|
|
2267
2322
|
},
|
|
2268
|
-
async conversations(
|
|
2323
|
+
async conversations(query2) {
|
|
2269
2324
|
await sync();
|
|
2270
|
-
return store.conversations(
|
|
2325
|
+
return store.conversations(query2);
|
|
2271
2326
|
},
|
|
2272
|
-
async messages(
|
|
2327
|
+
async messages(query2) {
|
|
2273
2328
|
await sync();
|
|
2274
|
-
return store.messages(
|
|
2329
|
+
return store.messages(query2);
|
|
2275
2330
|
},
|
|
2276
2331
|
async send(request) {
|
|
2277
2332
|
const availability = signerAvailability(signerOf2(), "nip44");
|
|
@@ -2369,9 +2424,9 @@ function createSealedGroupStore(options, name) {
|
|
|
2369
2424
|
const loading = open();
|
|
2370
2425
|
let writes = loading;
|
|
2371
2426
|
const seal = async (entries) => {
|
|
2372
|
-
const
|
|
2427
|
+
const text3 = JSON.stringify(Object.fromEntries(entries), encode);
|
|
2373
2428
|
const parts = [];
|
|
2374
|
-
for (let start = 0; start <
|
|
2429
|
+
for (let start = 0; start < text3.length; start += SEAL_UNITS) parts.push(text3.slice(start, start + SEAL_UNITS));
|
|
2375
2430
|
storage.setItem(key, JSON.stringify(await Promise.all(parts.map((part) => nip44.encrypt(owner, part)))));
|
|
2376
2431
|
};
|
|
2377
2432
|
const write = (change) => {
|
|
@@ -2572,13 +2627,13 @@ function createGroupMessagesBackend(options) {
|
|
|
2572
2627
|
capabilities: CAPABILITIES3
|
|
2573
2628
|
};
|
|
2574
2629
|
},
|
|
2575
|
-
async conversations(
|
|
2630
|
+
async conversations(query2) {
|
|
2576
2631
|
await sync();
|
|
2577
|
-
return store.conversations(
|
|
2632
|
+
return store.conversations(query2);
|
|
2578
2633
|
},
|
|
2579
|
-
async messages(
|
|
2634
|
+
async messages(query2) {
|
|
2580
2635
|
await sync();
|
|
2581
|
-
return store.messages(
|
|
2636
|
+
return store.messages(query2);
|
|
2582
2637
|
},
|
|
2583
2638
|
async send(request) {
|
|
2584
2639
|
const live = active();
|
|
@@ -2648,8 +2703,8 @@ function labelConversations(adapter, profiles) {
|
|
|
2648
2703
|
};
|
|
2649
2704
|
return {
|
|
2650
2705
|
...adapter,
|
|
2651
|
-
async conversations(
|
|
2652
|
-
const page2 = await adapter.conversations(
|
|
2706
|
+
async conversations(query2) {
|
|
2707
|
+
const page2 = await adapter.conversations(query2);
|
|
2653
2708
|
return { ...page2, conversations: await Promise.all(page2.conversations.map(named)) };
|
|
2654
2709
|
}
|
|
2655
2710
|
};
|
|
@@ -2799,12 +2854,104 @@ function createBlossomUploader(options) {
|
|
|
2799
2854
|
};
|
|
2800
2855
|
}
|
|
2801
2856
|
|
|
2857
|
+
// src/applets/applet-config.ts
|
|
2858
|
+
var STORAGE_KEY4 = "applet-config:v1";
|
|
2859
|
+
function createAppletConfig(options) {
|
|
2860
|
+
const store = createNamespacedStore(options.storage, "kernl");
|
|
2861
|
+
const read2 = () => store.getJson(STORAGE_KEY4, {});
|
|
2862
|
+
return {
|
|
2863
|
+
getValues(windowId) {
|
|
2864
|
+
const applet = options.appletOf(windowId);
|
|
2865
|
+
return applet ? { ...read2()[applet.key] } : {};
|
|
2866
|
+
},
|
|
2867
|
+
saveValues(windowId, values) {
|
|
2868
|
+
const applet = options.appletOf(windowId);
|
|
2869
|
+
if (applet) store.setJson(STORAGE_KEY4, { ...read2(), [applet.key]: values });
|
|
2870
|
+
},
|
|
2871
|
+
openSettings(windowId, section, context) {
|
|
2872
|
+
const applet = options.appletOf(windowId);
|
|
2873
|
+
if (applet) options.present({ title: applet.title, ...section ? { section } : {}, context });
|
|
2874
|
+
}
|
|
2875
|
+
};
|
|
2876
|
+
}
|
|
2877
|
+
|
|
2878
|
+
// src/social/common-actions.ts
|
|
2879
|
+
import { getProfileContent as getProfileContent2, normalizeToPubkey, unixNow as unixNow5 } from "applesauce-core/helpers";
|
|
2880
|
+
var FOLLOWS2 = 3;
|
|
2881
|
+
var REACTION = 7;
|
|
2882
|
+
var REPORT = 1984;
|
|
2883
|
+
var reasonOf = (error) => error instanceof Error ? error.message : String(error);
|
|
2884
|
+
function followed(event) {
|
|
2885
|
+
return (event?.tags ?? []).filter((tag) => tag[0] === "p" && typeof tag[1] === "string").map((tag) => tag[1]);
|
|
2886
|
+
}
|
|
2887
|
+
function toPubkey(value) {
|
|
2888
|
+
return normalizeToPubkey(value) ?? void 0;
|
|
2889
|
+
}
|
|
2890
|
+
async function signed(options, windowId, template) {
|
|
2891
|
+
const signer = options.signer();
|
|
2892
|
+
if (!signer) return { ok: false, error: "denied:read-only" };
|
|
2893
|
+
try {
|
|
2894
|
+
await options.consent(windowId, template);
|
|
2895
|
+
const event = await signer.signEvent(template);
|
|
2896
|
+
await options.publish(event);
|
|
2897
|
+
options.store.add(event);
|
|
2898
|
+
return { ok: true, eventId: event.id, event };
|
|
2899
|
+
} catch (error) {
|
|
2900
|
+
return { ok: false, error: reasonOf(error) };
|
|
2901
|
+
}
|
|
2902
|
+
}
|
|
2903
|
+
async function changeFollows(options, windowId, pubkeys, add) {
|
|
2904
|
+
const self = options.pubkey();
|
|
2905
|
+
if (!self) return { ok: false, error: "denied:read-only" };
|
|
2906
|
+
const targets = pubkeys.map(toPubkey);
|
|
2907
|
+
if (targets.some((key) => key === void 0)) return { ok: false, error: "invalid:pubkey" };
|
|
2908
|
+
await options.loadFollows(self);
|
|
2909
|
+
const previous = options.store.getReplaceable(FOLLOWS2, self);
|
|
2910
|
+
const current = followed(previous);
|
|
2911
|
+
const next = add ? [.../* @__PURE__ */ new Set([...current, ...targets])] : current.filter((key) => !targets.includes(key));
|
|
2912
|
+
const others = (previous?.tags ?? []).filter((tag) => tag[0] !== "p");
|
|
2913
|
+
const tags = [...next.map((key) => ["p", key]), ...others];
|
|
2914
|
+
return signed(options, windowId, { kind: FOLLOWS2, created_at: Math.max(unixNow5(), (previous?.created_at ?? 0) + 1), tags, content: previous?.content ?? "" });
|
|
2915
|
+
}
|
|
2916
|
+
function createCommonActions(options) {
|
|
2917
|
+
return {
|
|
2918
|
+
async getProfile(target) {
|
|
2919
|
+
const pubkey = toPubkey(target);
|
|
2920
|
+
if (!pubkey) return { ok: false, pubkey: "", error: "invalid:pubkey" };
|
|
2921
|
+
const card = await options.profiles.settled(pubkey);
|
|
2922
|
+
const event = options.store.getReplaceable(0, pubkey);
|
|
2923
|
+
const content = event ? getProfileContent2(event) : void 0;
|
|
2924
|
+
if (!card.found || !content) return { ok: true, pubkey, profile: null };
|
|
2925
|
+
const { display_name: displayName, ...rest } = content;
|
|
2926
|
+
return { ok: true, pubkey, profile: { ...rest, ...displayName ? { displayName } : {} } };
|
|
2927
|
+
},
|
|
2928
|
+
async follows() {
|
|
2929
|
+
const self = options.pubkey();
|
|
2930
|
+
if (!self) return { ok: false, pubkeys: [], error: "denied:signed-out" };
|
|
2931
|
+
await options.loadFollows(self);
|
|
2932
|
+
return { ok: true, pubkeys: followed(options.store.getReplaceable(FOLLOWS2, self)) };
|
|
2933
|
+
},
|
|
2934
|
+
follow: (pubkeys, context) => changeFollows(options, context.windowId, pubkeys, true),
|
|
2935
|
+
unfollow: (pubkeys, context) => changeFollows(options, context.windowId, pubkeys, false),
|
|
2936
|
+
react(targetEventId, reaction, customEmojiHref, context) {
|
|
2937
|
+
const target = options.store.getEvent(targetEventId);
|
|
2938
|
+
const emoji = customEmojiHref && /^:[\w-]+:$/.test(reaction) ? [["emoji", reaction.slice(1, -1), customEmojiHref]] : [];
|
|
2939
|
+
const tags = [["e", targetEventId], ...target ? [["p", target.pubkey], ["k", String(target.kind)]] : [], ...emoji];
|
|
2940
|
+
return signed(options, context.windowId, { kind: REACTION, created_at: unixNow5(), tags, content: reaction });
|
|
2941
|
+
},
|
|
2942
|
+
report(target, reason, text3, context) {
|
|
2943
|
+
const tags = target.type === "event" ? [["e", target.id, reason], ...target.pubkey ? [["p", target.pubkey]] : []] : [["p", target.pubkey, reason]];
|
|
2944
|
+
return signed(options, context.windowId, { kind: REPORT, created_at: unixNow5(), tags, content: text3 });
|
|
2945
|
+
}
|
|
2946
|
+
};
|
|
2947
|
+
}
|
|
2948
|
+
|
|
2802
2949
|
// src/kernl-network.ts
|
|
2803
|
-
import { map as map7, takeUntil as takeUntil2 } from "rxjs";
|
|
2950
|
+
import { lastValueFrom as lastValueFrom7, map as map7, takeUntil as takeUntil2 } from "rxjs";
|
|
2804
2951
|
|
|
2805
2952
|
// src/profiles/profiles.ts
|
|
2806
2953
|
import { catchError as catchError3, distinctUntilChanged as distinctUntilChanged2, EMPTY as EMPTY3, 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 timer4 } from "rxjs";
|
|
2807
|
-
import { getDisplayName, getOutboxes as getOutboxes3, getProfileContent as
|
|
2954
|
+
import { getDisplayName, getOutboxes as getOutboxes3, getProfileContent as getProfileContent3, getProfilePicture } from "applesauce-core/helpers";
|
|
2808
2955
|
var PROFILE_KIND = 0;
|
|
2809
2956
|
var MAILBOX_KIND = 10002;
|
|
2810
2957
|
var KEEP_ALIVE_MS = 6e4;
|
|
@@ -2815,7 +2962,7 @@ function safePicture(event) {
|
|
|
2815
2962
|
}
|
|
2816
2963
|
function toProfileCard(pubkey, event) {
|
|
2817
2964
|
const fallback = abbreviate(pubkey);
|
|
2818
|
-
const content = event ?
|
|
2965
|
+
const content = event ? getProfileContent3(event) : void 0;
|
|
2819
2966
|
if (!event || !content) return Object.freeze({ pubkey, name: fallback, found: false });
|
|
2820
2967
|
const name = getDisplayName(content)?.trim();
|
|
2821
2968
|
const picture = safePicture(event);
|
|
@@ -2912,17 +3059,668 @@ function createKernlNetwork(options, parts) {
|
|
|
2912
3059
|
});
|
|
2913
3060
|
return { eventCache, replaceableLoader, profiles, directory, mailboxes, files, signer };
|
|
2914
3061
|
}
|
|
3062
|
+
function commonActionsFor(parts, network, consent) {
|
|
3063
|
+
const { eventStore, pool, tiers, accounts } = parts;
|
|
3064
|
+
return createCommonActions({
|
|
3065
|
+
store: eventStore,
|
|
3066
|
+
profiles: network.profiles,
|
|
3067
|
+
pubkey: () => accounts.active?.pubkey,
|
|
3068
|
+
signer: network.signer,
|
|
3069
|
+
consent,
|
|
3070
|
+
publish: (event) => publishAccepted(pool, selectRelayTier(tiers, [{ kinds: [event.kind] }]), event),
|
|
3071
|
+
loadFollows: (pubkey) => lastValueFrom7(network.replaceableLoader({ kind: 3, pubkey, relays: lookupRelaysOf(tiers.get()) }), { defaultValue: void 0 }).then(
|
|
3072
|
+
() => void 0,
|
|
3073
|
+
() => void 0
|
|
3074
|
+
)
|
|
3075
|
+
});
|
|
3076
|
+
}
|
|
3077
|
+
|
|
3078
|
+
// src/multiplayer/remote-tools.ts
|
|
3079
|
+
import { createCvmService } from "@kehto/services";
|
|
3080
|
+
import { createNostrCvmTransport } from "@kehto/services/cvm-nostr-transport";
|
|
3081
|
+
function mergeFamilies(host, own) {
|
|
3082
|
+
const key = (family) => `${family.family}:${family.server.pubkey}`;
|
|
3083
|
+
const chosen = new Set(own.map(key));
|
|
3084
|
+
return [...host.filter((family) => !chosen.has(key(family))), ...own];
|
|
3085
|
+
}
|
|
3086
|
+
function createCvmRelayPool(pool) {
|
|
3087
|
+
return {
|
|
3088
|
+
subscribe(relays2, filter3, params) {
|
|
3089
|
+
const handle = subscribeWithEose(pool, relays2, [filter3], (item) => {
|
|
3090
|
+
if (item === "EOSE") params.oneose?.();
|
|
3091
|
+
else params.onevent?.(item);
|
|
3092
|
+
});
|
|
3093
|
+
return { close: () => handle.unsubscribe() };
|
|
3094
|
+
},
|
|
3095
|
+
async publish(relays2, event) {
|
|
3096
|
+
await publishAccepted(pool, relays2, event);
|
|
3097
|
+
}
|
|
3098
|
+
};
|
|
3099
|
+
}
|
|
3100
|
+
function createRemoteToolsService(options) {
|
|
3101
|
+
const windows = /* @__PURE__ */ new Map();
|
|
3102
|
+
let runtime;
|
|
3103
|
+
const serviceFor = (windowId) => {
|
|
3104
|
+
let service = windows.get(windowId);
|
|
3105
|
+
if (!service) {
|
|
3106
|
+
const transport = createNostrCvmTransport({
|
|
3107
|
+
pool: createCvmRelayPool(options.pool),
|
|
3108
|
+
defaultRelays: [...options.relays()],
|
|
3109
|
+
clientSecretKey: options.identities.signer(windowId).key
|
|
3110
|
+
});
|
|
3111
|
+
service = createCvmService({ transport, ...options.registry ? { registry: options.registry() } : {} });
|
|
3112
|
+
if (runtime) service.onRegistered?.(runtime);
|
|
3113
|
+
windows.set(windowId, service);
|
|
3114
|
+
}
|
|
3115
|
+
return service;
|
|
3116
|
+
};
|
|
3117
|
+
const end = (windowId) => {
|
|
3118
|
+
const service = windows.get(windowId);
|
|
3119
|
+
windows.delete(windowId);
|
|
3120
|
+
service?.onWindowDestroyed?.(windowId);
|
|
3121
|
+
service?.dispose();
|
|
3122
|
+
options.identities.release(windowId);
|
|
3123
|
+
};
|
|
3124
|
+
return {
|
|
3125
|
+
descriptor: { name: "cvm", version: "1.0.0", description: "Remote tools, each window calling under its own key" },
|
|
3126
|
+
onRegistered(context) {
|
|
3127
|
+
runtime = context;
|
|
3128
|
+
},
|
|
3129
|
+
onUnregistered() {
|
|
3130
|
+
for (const windowId of windows.keys()) end(windowId);
|
|
3131
|
+
runtime = void 0;
|
|
3132
|
+
},
|
|
3133
|
+
handleMessage(windowId, message, send) {
|
|
3134
|
+
serviceFor(windowId).handleMessage(windowId, message, send);
|
|
3135
|
+
},
|
|
3136
|
+
onWindowDestroyed: end,
|
|
3137
|
+
onPermissionRevoked: end
|
|
3138
|
+
};
|
|
3139
|
+
}
|
|
3140
|
+
|
|
3141
|
+
// src/multiplayer/window-identities.ts
|
|
3142
|
+
import { PrivateKeySigner as PrivateKeySigner2 } from "applesauce-signers";
|
|
3143
|
+
function createWindowIdentities() {
|
|
3144
|
+
const signers = /* @__PURE__ */ new Map();
|
|
3145
|
+
return {
|
|
3146
|
+
signer(windowId) {
|
|
3147
|
+
let signer = signers.get(windowId);
|
|
3148
|
+
if (!signer) {
|
|
3149
|
+
signer = new PrivateKeySigner2();
|
|
3150
|
+
signers.set(windowId, signer);
|
|
3151
|
+
}
|
|
3152
|
+
return signer;
|
|
3153
|
+
},
|
|
3154
|
+
release(windowId) {
|
|
3155
|
+
signers.get(windowId)?.key.fill(0);
|
|
3156
|
+
signers.delete(windowId);
|
|
3157
|
+
}
|
|
3158
|
+
};
|
|
3159
|
+
}
|
|
3160
|
+
|
|
3161
|
+
// src/multiplayer/settings.ts
|
|
3162
|
+
import { BehaviorSubject as BehaviorSubject7 } from "rxjs";
|
|
3163
|
+
var STORAGE_KEY5 = "multiplayer:v1";
|
|
3164
|
+
var HEX_KEY3 = /^[0-9a-f]{64}$/u;
|
|
3165
|
+
var HELPER_URL = /^(stuns?|turns?):\S+$/u;
|
|
3166
|
+
var RELAY_URL = /^wss?:\/\/\S+$/u;
|
|
3167
|
+
var text2 = (value) => typeof value === "string" && value.trim().length > 0 && value.length <= 256;
|
|
3168
|
+
function validServers(urls) {
|
|
3169
|
+
return urls.length <= 16 && urls.every((url) => typeof url === "string" && RELAY_URL.test(url));
|
|
3170
|
+
}
|
|
3171
|
+
function validHelper(helper) {
|
|
3172
|
+
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");
|
|
3173
|
+
}
|
|
3174
|
+
function validFamily(family) {
|
|
3175
|
+
const { server, tools } = family;
|
|
3176
|
+
return text2(family.family) && HEX_KEY3.test(server.pubkey) && validServers(server.relays ?? []) && Array.isArray(tools) && tools.length > 0 && tools.length <= 64 && tools.every((tool) => text2(tool.name) && HEX_KEY3.test(tool.schemaHash)) && new Set(tools.map((tool) => tool.name)).size === tools.length;
|
|
3177
|
+
}
|
|
3178
|
+
function read(raw) {
|
|
3179
|
+
const families = Array.isArray(raw.families) ? raw.families.filter(validFamily).slice(0, 16) : [];
|
|
3180
|
+
return Object.freeze({
|
|
3181
|
+
...Array.isArray(raw.servers) && validServers(raw.servers) ? { servers: raw.servers } : {},
|
|
3182
|
+
...Array.isArray(raw.helpers) && raw.helpers.every(validHelper) ? { helpers: raw.helpers } : {},
|
|
3183
|
+
families
|
|
3184
|
+
});
|
|
3185
|
+
}
|
|
3186
|
+
function createMultiplayerSettings(storage) {
|
|
3187
|
+
const store = createNamespacedStore(storage, "kernl");
|
|
3188
|
+
const state$ = new BehaviorSubject7(read(store.getJson(STORAGE_KEY5, {})));
|
|
3189
|
+
const commit = (next) => {
|
|
3190
|
+
const state = read(next);
|
|
3191
|
+
store.setJson(STORAGE_KEY5, state);
|
|
3192
|
+
state$.next(state);
|
|
3193
|
+
};
|
|
3194
|
+
const without = (key) => {
|
|
3195
|
+
const { [key]: _dropped, ...rest } = state$.value;
|
|
3196
|
+
return rest;
|
|
3197
|
+
};
|
|
3198
|
+
return {
|
|
3199
|
+
state$: state$.asObservable(),
|
|
3200
|
+
state: () => state$.value,
|
|
3201
|
+
setServers(urls) {
|
|
3202
|
+
if (urls && !validServers(urls)) throw new Error("invalid:relay-url");
|
|
3203
|
+
commit(urls ? { ...state$.value, servers: [...new Set(urls)] } : without("servers"));
|
|
3204
|
+
},
|
|
3205
|
+
setHelpers(helpers) {
|
|
3206
|
+
if (helpers && !(helpers.length <= 8 && helpers.every(validHelper))) throw new Error("invalid:helper");
|
|
3207
|
+
commit(helpers ? { ...state$.value, helpers } : without("helpers"));
|
|
3208
|
+
},
|
|
3209
|
+
saveFamily(family) {
|
|
3210
|
+
if (!validFamily(family)) throw new Error("invalid:family");
|
|
3211
|
+
const others = state$.value.families.filter((saved) => saved.family !== family.family || saved.server.pubkey !== family.server.pubkey);
|
|
3212
|
+
if (others.length >= 16) throw new Error("invalid:family");
|
|
3213
|
+
commit({ ...state$.value, families: [...others, family] });
|
|
3214
|
+
},
|
|
3215
|
+
removeFamily(label, pubkey) {
|
|
3216
|
+
commit({ ...state$.value, families: state$.value.families.filter((saved) => saved.family !== label || saved.server.pubkey !== pubkey) });
|
|
3217
|
+
}
|
|
3218
|
+
};
|
|
3219
|
+
}
|
|
3220
|
+
|
|
3221
|
+
// src/multiplayer/tool-discovery.ts
|
|
3222
|
+
import { lastValueFrom as lastValueFrom8, takeUntil as takeUntil3, timer as timer5, toArray as toArray5 } from "rxjs";
|
|
3223
|
+
import { decodeEventPointer as decodeEventPointer2, verifyEvent as verifyEvent4 } from "applesauce-core/helpers";
|
|
3224
|
+
import { computeCvmToolSchemaHash } from "@kehto/services";
|
|
3225
|
+
var KIND_SERVER = 11316;
|
|
3226
|
+
var KIND_TOOLS = 11317;
|
|
3227
|
+
var KIND_RELAY_LIST = 10002;
|
|
3228
|
+
var HASH = /^[0-9a-f]{64}$/u;
|
|
3229
|
+
var MAX_BYTES = 1e6;
|
|
3230
|
+
var MAX_TOOLS = 64;
|
|
3231
|
+
var TOOL_DISCOVERY_TIMEOUT_MS = 15e3;
|
|
3232
|
+
var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
|
|
3233
|
+
function parseJson2(text3) {
|
|
3234
|
+
try {
|
|
3235
|
+
return JSON.parse(text3);
|
|
3236
|
+
} catch {
|
|
3237
|
+
return void 0;
|
|
3238
|
+
}
|
|
3239
|
+
}
|
|
3240
|
+
function parse(input) {
|
|
3241
|
+
const typed = input.trim().replace(/^nostr:/iu, "");
|
|
3242
|
+
if (HASH.test(typed.toLowerCase())) return { type: "hash", hash: typed.toLowerCase() };
|
|
3243
|
+
if (/^nevent1/iu.test(typed)) {
|
|
3244
|
+
const pointer = decodeEventPointer2(typed);
|
|
3245
|
+
if (!pointer || pointer.kind !== void 0 && pointer.kind !== KIND_SERVER && pointer.kind !== KIND_TOOLS) throw new Error("invalid:tool-reference");
|
|
3246
|
+
return { type: "event", id: pointer.id, ...pointer.author ? { author: pointer.author } : {}, relays: pointer.relays };
|
|
3247
|
+
}
|
|
3248
|
+
let url;
|
|
3249
|
+
try {
|
|
3250
|
+
url = new URL(typed.includes("://") ? typed : `https://${typed}`);
|
|
3251
|
+
} catch {
|
|
3252
|
+
throw new Error("invalid:tool-reference");
|
|
3253
|
+
}
|
|
3254
|
+
if (url.protocol !== "https:" || url.username || url.password || !url.hostname.includes(".")) throw new Error("invalid:tool-reference");
|
|
3255
|
+
return { type: "website", url: `${url.origin}/.well-known/napplet.json` };
|
|
3256
|
+
}
|
|
3257
|
+
async function query(options, relays2, filter3) {
|
|
3258
|
+
const limit = options.timeoutMs ?? TOOL_DISCOVERY_TIMEOUT_MS;
|
|
3259
|
+
const events = await lastValueFrom8(options.pool.request([...relays2], asFilters([{ ...filter3, limit: MAX_TOOLS }])).pipe(takeUntil3(timer5(limit)), toArray5()));
|
|
3260
|
+
return events.filter((event) => event.content.length <= MAX_BYTES && verifyEvent4(event)).sort((a, b) => b.created_at - a.created_at);
|
|
3261
|
+
}
|
|
3262
|
+
async function websiteProvider(url, options) {
|
|
3263
|
+
const response = await options.fetch(url, { credentials: "omit", redirect: "error", referrerPolicy: "no-referrer" }).catch(() => void 0);
|
|
3264
|
+
const body = response?.ok ? await response.text() : "";
|
|
3265
|
+
const document = body.length <= MAX_BYTES ? parseJson2(body) : void 0;
|
|
3266
|
+
const backend = record(document) && document.version === 1 ? document.backend : void 0;
|
|
3267
|
+
if (!record(backend) || typeof backend.pubkey !== "string" || !HASH.test(backend.pubkey) || !Array.isArray(backend.relays)) throw new Error("unavailable:website");
|
|
3268
|
+
return { pubkey: backend.pubkey, relays: backend.relays.filter((relay) => typeof relay === "string") };
|
|
3269
|
+
}
|
|
3270
|
+
async function inventory(event) {
|
|
3271
|
+
const payload = parseJson2(event.content);
|
|
3272
|
+
const listed = record(payload) && Array.isArray(payload.tools) ? payload.tools : [];
|
|
3273
|
+
if (listed.length === 0 || listed.length > MAX_TOOLS) throw new Error("invalid:tool-inventory");
|
|
3274
|
+
const tools = [];
|
|
3275
|
+
for (const raw of listed) {
|
|
3276
|
+
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");
|
|
3277
|
+
const schemaHash = await computeCvmToolSchemaHash({ name: raw.name, inputSchema: raw.inputSchema, ...record(raw.outputSchema) ? { outputSchema: raw.outputSchema } : {} });
|
|
3278
|
+
const tagged = event.tags.filter((tag) => tag[0] === "i" && tag[2] === raw.name);
|
|
3279
|
+
if (tagged.some((tag) => tag[1] !== schemaHash)) throw new Error("invalid:tool-inventory");
|
|
3280
|
+
tools.push({ name: raw.name, schemaHash });
|
|
3281
|
+
}
|
|
3282
|
+
return tools;
|
|
3283
|
+
}
|
|
3284
|
+
function providerRelays(lists, pubkey, found) {
|
|
3285
|
+
const listed = lists.find((list) => list.pubkey === pubkey)?.tags.filter((tag) => tag[0] === "r" && typeof tag[1] === "string") ?? [];
|
|
3286
|
+
const unmarked = listed.filter((tag) => !tag[2]);
|
|
3287
|
+
const chosen = (unmarked.length > 0 ? unmarked : listed).map((tag) => tag[1]);
|
|
3288
|
+
return chosen.length > 0 ? chosen : [...found];
|
|
3289
|
+
}
|
|
3290
|
+
async function announcements(reference, options) {
|
|
3291
|
+
if (reference.type === "website") {
|
|
3292
|
+
const provider = await websiteProvider(reference.url, options);
|
|
3293
|
+
return { events: await query(options, provider.relays, { kinds: [KIND_TOOLS], authors: [provider.pubkey] }), relays: provider.relays };
|
|
3294
|
+
}
|
|
3295
|
+
const relays2 = reference.type === "event" && reference.relays.length > 0 ? reference.relays : options.relays;
|
|
3296
|
+
if (reference.type === "hash") return { events: await query(options, relays2, { kinds: [KIND_TOOLS], "#i": [reference.hash] }), relays: relays2 };
|
|
3297
|
+
const found = await query(options, relays2, { ids: [reference.id], kinds: [KIND_SERVER, KIND_TOOLS], ...reference.author ? { authors: [reference.author] } : {} });
|
|
3298
|
+
const first = found[0];
|
|
3299
|
+
if (first?.kind === KIND_SERVER) return { events: await query(options, relays2, { kinds: [KIND_TOOLS], authors: [first.pubkey] }), relays: relays2 };
|
|
3300
|
+
return { events: found, relays: relays2 };
|
|
3301
|
+
}
|
|
3302
|
+
async function discoverToolFamilies(input, options) {
|
|
3303
|
+
const reference = parse(input);
|
|
3304
|
+
const { events, relays: relays2 } = await announcements(reference, options);
|
|
3305
|
+
const newest2 = /* @__PURE__ */ new Map();
|
|
3306
|
+
for (const event of events) if (event.kind === KIND_TOOLS && !newest2.has(event.pubkey)) newest2.set(event.pubkey, event);
|
|
3307
|
+
if (newest2.size === 0) throw new Error("unavailable:no-tools");
|
|
3308
|
+
const lists = reference.type === "website" ? [] : await query(options, relays2, { kinds: [KIND_RELAY_LIST], authors: [...newest2.keys()] });
|
|
3309
|
+
const candidates = [];
|
|
3310
|
+
for (const event of newest2.values()) {
|
|
3311
|
+
const tools = await inventory(event);
|
|
3312
|
+
if (reference.type === "hash" && !tools.some((tool) => tool.schemaHash === reference.hash)) continue;
|
|
3313
|
+
candidates.push({
|
|
3314
|
+
family: { family: `tools.${event.pubkey.slice(0, 12)}`, server: { pubkey: event.pubkey, relays: providerRelays(lists, event.pubkey, relays2) }, tools },
|
|
3315
|
+
eventId: event.id,
|
|
3316
|
+
source: `${input.trim()} \xB7 ${event.id.slice(0, 12)}`
|
|
3317
|
+
});
|
|
3318
|
+
}
|
|
3319
|
+
if (candidates.length === 0) throw new Error("unavailable:no-tools");
|
|
3320
|
+
return candidates;
|
|
3321
|
+
}
|
|
3322
|
+
|
|
3323
|
+
// src/multiplayer/direct-connections.ts
|
|
3324
|
+
import { createWebrtcService } from "@kehto/services";
|
|
3325
|
+
|
|
3326
|
+
// src/multiplayer/direct-signaling.ts
|
|
3327
|
+
import { verifyEvent as verifyEvent5 } from "applesauce-core/helpers";
|
|
3328
|
+
var DIRECT_SIGNALING_PROFILE = "soy-rtc/1";
|
|
3329
|
+
var DIRECT_SIGNAL_KIND = 25050;
|
|
3330
|
+
var DIRECT_MAX_PAYLOAD_BYTES = 16384;
|
|
3331
|
+
var MAX_SESSIONS = 4;
|
|
3332
|
+
var MAX_PEERS = 8;
|
|
3333
|
+
var HELLO_EVERY_MS = 2e3;
|
|
3334
|
+
var JOIN_PATIENCE_MS = 45e3;
|
|
3335
|
+
var GATHER_PATIENCE_MS = 8e3;
|
|
3336
|
+
var SIGNAL_LIFETIME_S = 60;
|
|
3337
|
+
var SIGNALS_PER_SECOND = 32;
|
|
3338
|
+
var MESSAGES_PER_SECOND = 240;
|
|
3339
|
+
var BYTES_PER_SECOND = 524288;
|
|
3340
|
+
var MAX_SIGNAL_CHARS = 64e3;
|
|
3341
|
+
var MAX_SDP_CHARS = 32e3;
|
|
3342
|
+
var UNSET_LIMIT = 65535;
|
|
3343
|
+
var HEX_KEY4 = /^[0-9a-f]{64}$/u;
|
|
3344
|
+
var encoder = new TextEncoder();
|
|
3345
|
+
function invalid2(message) {
|
|
3346
|
+
throw new Error(message);
|
|
3347
|
+
}
|
|
3348
|
+
function validate(request) {
|
|
3349
|
+
const { scope } = request;
|
|
3350
|
+
if (scope.type === "room") {
|
|
3351
|
+
if (typeof scope.room !== "string" || !scope.room || scope.room.length > 256) invalid2("invalid room");
|
|
3352
|
+
if (scope.peers && (scope.peers.length > MAX_PEERS || !scope.peers.every((key) => HEX_KEY4.test(key)))) invalid2("invalid peers");
|
|
3353
|
+
} else if (scope.type !== "direct" || !HEX_KEY4.test(scope.pubkey)) invalid2("invalid scope");
|
|
3354
|
+
if (request.channel !== void 0 && (!request.channel || request.channel.length > 64)) invalid2("invalid channel");
|
|
3355
|
+
if (request.protocol !== void 0 && request.protocol.length > 128) invalid2("invalid protocol");
|
|
3356
|
+
}
|
|
3357
|
+
function reliable(body) {
|
|
3358
|
+
if (body.realtime === void 0) return true;
|
|
3359
|
+
const realtime = body.realtime;
|
|
3360
|
+
return realtime?.profile === "soy-rtc/realtime-1" && realtime.ordered === true && realtime.maxRetransmits === null;
|
|
3361
|
+
}
|
|
3362
|
+
function reliableChannel(channel) {
|
|
3363
|
+
return channel.ordered && [channel.maxRetransmits, channel.maxPacketLifeTime].every((limit) => limit === null || limit === UNSET_LIMIT);
|
|
3364
|
+
}
|
|
3365
|
+
function gathered(connection) {
|
|
3366
|
+
return new Promise((resolve) => {
|
|
3367
|
+
const finish = () => {
|
|
3368
|
+
clearTimeout(timer8);
|
|
3369
|
+
connection.removeEventListener("icegatheringstatechange", changed);
|
|
3370
|
+
resolve();
|
|
3371
|
+
};
|
|
3372
|
+
const changed = () => {
|
|
3373
|
+
if (connection.iceGatheringState === "complete") finish();
|
|
3374
|
+
};
|
|
3375
|
+
const timer8 = setTimeout(finish, GATHER_PATIENCE_MS);
|
|
3376
|
+
connection.addEventListener("icegatheringstatechange", changed);
|
|
3377
|
+
changed();
|
|
3378
|
+
});
|
|
3379
|
+
}
|
|
3380
|
+
async function wireOf(namespace, self, request, channel) {
|
|
3381
|
+
const { scope } = request;
|
|
3382
|
+
const where = scope.type === "room" ? ["room", scope.room] : ["direct", ...[self, scope.pubkey].sort()];
|
|
3383
|
+
const identity = JSON.stringify([DIRECT_SIGNALING_PROFILE, namespace, where, channel, request.protocol ?? ""]);
|
|
3384
|
+
const digest = await crypto.subtle.digest("SHA-256", encoder.encode(identity));
|
|
3385
|
+
return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
|
|
3386
|
+
}
|
|
3387
|
+
function forgetStale(memory, now) {
|
|
3388
|
+
for (const [key, at] of memory) {
|
|
3389
|
+
if (now - at <= SIGNAL_LIFETIME_S * 1e3) break;
|
|
3390
|
+
memory.delete(key);
|
|
3391
|
+
}
|
|
3392
|
+
}
|
|
3393
|
+
function createDirectSignaling(options) {
|
|
3394
|
+
const signaling = new DirectSignaling(options);
|
|
3395
|
+
return {
|
|
3396
|
+
planOpen: (request) => signaling.planOpen(request),
|
|
3397
|
+
open: (request, context) => signaling.open(request, context),
|
|
3398
|
+
send: (id, payload, context) => signaling.send(id, payload, context),
|
|
3399
|
+
close: (id, reason, context) => signaling.close(signaling.sessionFor(id, context), reason),
|
|
3400
|
+
destroyWindow: () => signaling.closeAll(),
|
|
3401
|
+
revokeWindow: () => signaling.closeAll()
|
|
3402
|
+
};
|
|
3403
|
+
}
|
|
3404
|
+
var DirectSignaling = class {
|
|
3405
|
+
constructor(options) {
|
|
3406
|
+
this.options = options;
|
|
3407
|
+
this.self = options.signer.getPublicKey();
|
|
3408
|
+
}
|
|
3409
|
+
options;
|
|
3410
|
+
sessions = /* @__PURE__ */ new Map();
|
|
3411
|
+
self;
|
|
3412
|
+
planOpen(request) {
|
|
3413
|
+
validate(request);
|
|
3414
|
+
if (this.options.relays.length === 0) invalid2("signaling unavailable");
|
|
3415
|
+
const resource = request.scope.type === "room" ? `room:${request.scope.room}` : `peer:${request.scope.pubkey}`;
|
|
3416
|
+
return { signalingRelayUrls: this.options.relays, iceEndpoints: this.options.iceEndpoints, resource };
|
|
3417
|
+
}
|
|
3418
|
+
async open(request, context) {
|
|
3419
|
+
validate(request);
|
|
3420
|
+
const me = await this.self;
|
|
3421
|
+
if (this.sessions.size >= MAX_SESSIONS) invalid2("session limit reached");
|
|
3422
|
+
if (request.scope.type === "direct" && request.scope.pubkey === me) invalid2("cannot connect to self");
|
|
3423
|
+
const channel = request.channel ?? "napplet";
|
|
3424
|
+
const wire = await wireOf(this.options.namespace, me, request, channel);
|
|
3425
|
+
if ([...this.sessions.values()].some((session2) => session2.wire === wire)) invalid2("scope already open");
|
|
3426
|
+
const session = {
|
|
3427
|
+
id: crypto.randomUUID(),
|
|
3428
|
+
wire,
|
|
3429
|
+
nonce: crypto.randomUUID(),
|
|
3430
|
+
request,
|
|
3431
|
+
channel,
|
|
3432
|
+
context,
|
|
3433
|
+
peers: /* @__PURE__ */ new Map(),
|
|
3434
|
+
retired: /* @__PURE__ */ new Map(),
|
|
3435
|
+
seen: /* @__PURE__ */ new Map(),
|
|
3436
|
+
signals: { since: Date.now(), count: 0 },
|
|
3437
|
+
open: false
|
|
3438
|
+
};
|
|
3439
|
+
this.sessions.set(session.id, session);
|
|
3440
|
+
context.signal?.addEventListener("abort", () => this.close(session), { once: true });
|
|
3441
|
+
this.start(session);
|
|
3442
|
+
const { protocol } = request;
|
|
3443
|
+
return { session: { id: session.id, scope: request.scope, channel, ...protocol ? { protocol } : {}, state: "connecting" } };
|
|
3444
|
+
}
|
|
3445
|
+
send(id, payload, context) {
|
|
3446
|
+
const session = this.sessionFor(id, context);
|
|
3447
|
+
const json = JSON.stringify(payload);
|
|
3448
|
+
const size = json === void 0 ? Infinity : encoder.encode(json).length;
|
|
3449
|
+
if (size > DIRECT_MAX_PAYLOAD_BYTES) invalid2("payload is not JSON of at most 16 KiB");
|
|
3450
|
+
const channels = [...session.peers.values()].filter((peer) => peer.joined && peer.channel?.readyState === "open").map((peer) => peer.channel);
|
|
3451
|
+
if (channels.length === 0) invalid2("peer unavailable");
|
|
3452
|
+
for (const channel of channels) channel.send(json);
|
|
3453
|
+
}
|
|
3454
|
+
sessionFor(id, context) {
|
|
3455
|
+
const session = this.sessions.get(id);
|
|
3456
|
+
if (!session || session.context.windowId !== context.windowId || !this.live(session)) throw new Error("session not found");
|
|
3457
|
+
return session;
|
|
3458
|
+
}
|
|
3459
|
+
close(session, reason) {
|
|
3460
|
+
if (!this.sessions.has(session.id)) return;
|
|
3461
|
+
this.emit(session, { type: "closed", sessionId: session.id, ...reason ? { reason } : {} });
|
|
3462
|
+
this.sessions.delete(session.id);
|
|
3463
|
+
clearInterval(session.timer);
|
|
3464
|
+
session.subscription?.close();
|
|
3465
|
+
for (const peer of session.peers.values()) this.removePeer(session, peer);
|
|
3466
|
+
}
|
|
3467
|
+
closeAll() {
|
|
3468
|
+
for (const session of this.sessions.values()) this.close(session);
|
|
3469
|
+
}
|
|
3470
|
+
live(session) {
|
|
3471
|
+
return this.sessions.get(session.id) === session && !session.context.signal?.aborted;
|
|
3472
|
+
}
|
|
3473
|
+
emit(session, event) {
|
|
3474
|
+
if (this.live(session)) session.context.emit(event);
|
|
3475
|
+
}
|
|
3476
|
+
activePeer(session, peer) {
|
|
3477
|
+
return this.live(session) && session.peers.get(peer.key) === peer;
|
|
3478
|
+
}
|
|
3479
|
+
removePeer(session, peer) {
|
|
3480
|
+
if (session.peers.get(peer.key) !== peer) return;
|
|
3481
|
+
session.peers.delete(peer.key);
|
|
3482
|
+
if (peer.joined) this.emit(session, { type: "peer", sessionId: session.id, pubkey: peer.key, state: "left" });
|
|
3483
|
+
peer.channel?.close();
|
|
3484
|
+
peer.connection.close();
|
|
3485
|
+
}
|
|
3486
|
+
async publish(session, body, recipient) {
|
|
3487
|
+
const { signer } = this.options;
|
|
3488
|
+
const raw = JSON.stringify({ v: DIRECT_SIGNALING_PROFILE, wire: session.wire, nonce: session.nonce, ...body });
|
|
3489
|
+
const now = Math.floor(Date.now() / 1e3);
|
|
3490
|
+
const event = await signer.signEvent({
|
|
3491
|
+
kind: DIRECT_SIGNAL_KIND,
|
|
3492
|
+
created_at: now,
|
|
3493
|
+
content: recipient ? await signer.nip44.encrypt(recipient, raw) : raw,
|
|
3494
|
+
tags: [["d", session.wire], ["expiration", String(now + SIGNAL_LIFETIME_S)], ...recipient ? [["p", recipient]] : []]
|
|
3495
|
+
});
|
|
3496
|
+
try {
|
|
3497
|
+
await this.options.relay.publish(this.options.relays, event);
|
|
3498
|
+
} catch {
|
|
3499
|
+
}
|
|
3500
|
+
}
|
|
3501
|
+
attach(session, peer, channel) {
|
|
3502
|
+
if (!this.activePeer(session, peer) || peer.channel || channel.label !== session.channel || channel.protocol !== "" || !reliableChannel(channel)) {
|
|
3503
|
+
channel.close();
|
|
3504
|
+
return;
|
|
3505
|
+
}
|
|
3506
|
+
peer.channel = channel;
|
|
3507
|
+
channel.addEventListener("open", () => {
|
|
3508
|
+
peer.joined = true;
|
|
3509
|
+
this.emit(session, { type: "peer", sessionId: session.id, pubkey: peer.key, state: "joined" });
|
|
3510
|
+
if (session.open) return;
|
|
3511
|
+
session.open = true;
|
|
3512
|
+
this.emit(session, { type: "state", sessionId: session.id, state: "open" });
|
|
3513
|
+
});
|
|
3514
|
+
const budget = { since: Date.now(), messages: 0, bytes: 0 };
|
|
3515
|
+
channel.addEventListener("message", (event) => {
|
|
3516
|
+
if (!this.activePeer(session, peer) || typeof event.data !== "string") return;
|
|
3517
|
+
const size = encoder.encode(event.data).length;
|
|
3518
|
+
if (Date.now() - budget.since > 1e3) Object.assign(budget, { since: Date.now(), messages: 0, bytes: 0 });
|
|
3519
|
+
budget.messages += 1;
|
|
3520
|
+
budget.bytes += size;
|
|
3521
|
+
if (size > DIRECT_MAX_PAYLOAD_BYTES || budget.messages > MESSAGES_PER_SECOND || budget.bytes > BYTES_PER_SECOND) return;
|
|
3522
|
+
try {
|
|
3523
|
+
this.emit(session, { type: "message", sessionId: session.id, from: peer.key, payload: JSON.parse(event.data) });
|
|
3524
|
+
} catch {
|
|
3525
|
+
}
|
|
3526
|
+
});
|
|
3527
|
+
channel.addEventListener("close", () => this.removePeer(session, peer));
|
|
3528
|
+
}
|
|
3529
|
+
/** Run a peer's negotiation steps one at a time; a step that fails drops the peer. */
|
|
3530
|
+
queue(session, peer, step) {
|
|
3531
|
+
peer.chain = peer.chain.then(step).catch(() => this.removePeer(session, peer));
|
|
3532
|
+
}
|
|
3533
|
+
async meet(session, key, nonce) {
|
|
3534
|
+
const known = session.peers.get(key);
|
|
3535
|
+
if (known && known.nonce !== nonce) {
|
|
3536
|
+
session.retired.set(`${key}:${known.nonce}`, Date.now());
|
|
3537
|
+
this.removePeer(session, known);
|
|
3538
|
+
} else if (known) return;
|
|
3539
|
+
if (session.peers.size >= MAX_PEERS) return;
|
|
3540
|
+
const peer = { key, nonce, connection: this.options.createPeer(), started: Date.now(), joined: false, chain: Promise.resolve() };
|
|
3541
|
+
session.peers.set(key, peer);
|
|
3542
|
+
peer.connection.addEventListener("datachannel", (event) => this.attach(session, peer, event.channel));
|
|
3543
|
+
peer.connection.addEventListener("connectionstatechange", () => {
|
|
3544
|
+
if (peer.connection.connectionState === "failed" || peer.connection.connectionState === "closed") this.removePeer(session, peer);
|
|
3545
|
+
});
|
|
3546
|
+
void this.publish(session, { type: "hello" });
|
|
3547
|
+
if (await this.self < key) this.queue(session, peer, () => this.offer(session, peer));
|
|
3548
|
+
}
|
|
3549
|
+
async offer(session, peer) {
|
|
3550
|
+
this.attach(session, peer, peer.connection.createDataChannel(session.channel, { ordered: true }));
|
|
3551
|
+
await peer.connection.setLocalDescription(await peer.connection.createOffer());
|
|
3552
|
+
await gathered(peer.connection);
|
|
3553
|
+
peer.offer = peer.connection.localDescription.sdp;
|
|
3554
|
+
await this.publish(session, { type: "offer", to: peer.nonce, sdp: peer.offer }, peer.key);
|
|
3555
|
+
}
|
|
3556
|
+
async answer(session, peer, sdp) {
|
|
3557
|
+
if (!peer.answer) {
|
|
3558
|
+
await peer.connection.setRemoteDescription({ type: "offer", sdp });
|
|
3559
|
+
await peer.connection.setLocalDescription(await peer.connection.createAnswer());
|
|
3560
|
+
await gathered(peer.connection);
|
|
3561
|
+
peer.answer = peer.connection.localDescription.sdp;
|
|
3562
|
+
}
|
|
3563
|
+
await this.publish(session, { type: "answer", to: peer.nonce, sdp: peer.answer }, peer.key);
|
|
3564
|
+
}
|
|
3565
|
+
async negotiate(session, peer, body) {
|
|
3566
|
+
const me = await this.self;
|
|
3567
|
+
const sdp = body.sdp;
|
|
3568
|
+
if (body.type === "offer" && peer.key < me) this.queue(session, peer, () => this.answer(session, peer, sdp));
|
|
3569
|
+
else if (body.type === "answer" && me < peer.key && !peer.connection.remoteDescription) {
|
|
3570
|
+
this.queue(session, peer, () => peer.connection.setRemoteDescription({ type: "answer", sdp }));
|
|
3571
|
+
}
|
|
3572
|
+
}
|
|
3573
|
+
admitted(session, event, me) {
|
|
3574
|
+
const now = Date.now();
|
|
3575
|
+
forgetStale(session.seen, now);
|
|
3576
|
+
forgetStale(session.retired, now);
|
|
3577
|
+
if (now - session.signals.since > 1e3) Object.assign(session.signals, { since: now, count: 0 });
|
|
3578
|
+
session.signals.count += 1;
|
|
3579
|
+
const { scope } = session.request;
|
|
3580
|
+
const fromAllowed = scope.type === "direct" ? event.pubkey === scope.pubkey : !scope.peers || scope.peers.includes(event.pubkey);
|
|
3581
|
+
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);
|
|
3582
|
+
}
|
|
3583
|
+
async receive(session, event) {
|
|
3584
|
+
const me = await this.self;
|
|
3585
|
+
if (!this.live(session) || !this.admitted(session, event, me)) return;
|
|
3586
|
+
const recipient = event.tags.find((tag) => tag[0] === "p")?.[1];
|
|
3587
|
+
if (recipient !== void 0 && recipient !== me) return;
|
|
3588
|
+
session.seen.set(event.id, Date.now());
|
|
3589
|
+
const body = JSON.parse(recipient ? await this.options.signer.nip44.decrypt(event.pubkey, event.content) : event.content);
|
|
3590
|
+
const shaped = body.v === DIRECT_SIGNALING_PROFILE && body.wire === session.wire && typeof body.nonce === "string" && body.nonce.length > 0 && body.nonce.length <= 64;
|
|
3591
|
+
if (!shaped || session.retired.has(`${event.pubkey}:${body.nonce}`) || !reliable(body)) return;
|
|
3592
|
+
if (!recipient) {
|
|
3593
|
+
if (body.type === "hello") await this.meet(session, event.pubkey, body.nonce);
|
|
3594
|
+
return;
|
|
3595
|
+
}
|
|
3596
|
+
const peer = session.peers.get(event.pubkey);
|
|
3597
|
+
if (!peer || peer.nonce !== body.nonce || body.to !== session.nonce || typeof body.sdp !== "string" || body.sdp.length > MAX_SDP_CHARS) return;
|
|
3598
|
+
await this.negotiate(session, peer, body);
|
|
3599
|
+
}
|
|
3600
|
+
start(session) {
|
|
3601
|
+
const filter3 = { kinds: [DIRECT_SIGNAL_KIND], "#d": [session.wire], since: Math.floor(Date.now() / 1e3) - 10 };
|
|
3602
|
+
session.subscription = this.options.relay.subscribe(this.options.relays, [filter3], (event) => {
|
|
3603
|
+
void this.receive(session, event).catch(() => void 0);
|
|
3604
|
+
});
|
|
3605
|
+
const tick = () => {
|
|
3606
|
+
void this.publish(session, { type: "hello" });
|
|
3607
|
+
for (const peer of session.peers.values()) {
|
|
3608
|
+
if (!peer.joined && Date.now() - peer.started > JOIN_PATIENCE_MS) this.removePeer(session, peer);
|
|
3609
|
+
else if (peer.offer && !peer.connection.remoteDescription) void this.publish(session, { type: "offer", to: peer.nonce, sdp: peer.offer }, peer.key);
|
|
3610
|
+
}
|
|
3611
|
+
};
|
|
3612
|
+
tick();
|
|
3613
|
+
session.timer = setInterval(tick, HELLO_EVERY_MS);
|
|
3614
|
+
}
|
|
3615
|
+
};
|
|
3616
|
+
|
|
3617
|
+
// src/multiplayer/direct-connections.ts
|
|
3618
|
+
function directNamespace(summary) {
|
|
3619
|
+
const [, kind, ...rest] = summary.manifest.catalogId.split(":");
|
|
3620
|
+
if (rest[0] === summary.publisher) rest.shift();
|
|
3621
|
+
return `${summary.publisher}:${kind}:${rest.join(":")}`;
|
|
3622
|
+
}
|
|
3623
|
+
function describeDirectConnection(requirements, applet) {
|
|
3624
|
+
const resource = requirements.find((requirement) => requirement.category === "resource").scope.value;
|
|
3625
|
+
const scoped = (kind) => requirements.filter((requirement) => requirement.category === "network" && requirement.scope.kind === kind).map((requirement) => requirement.scope.value);
|
|
3626
|
+
const relays2 = scoped("origin").map((origin) => new URL(origin).host);
|
|
3627
|
+
const helpers = scoped("ice");
|
|
3628
|
+
const draft = { kind: DIRECT_SIGNAL_KIND, content: "", tags: [["t", "direct"]], created_at: 0, pubkey: "", id: "", sig: "" };
|
|
3629
|
+
return {
|
|
3630
|
+
title: "Connect directly to other people",
|
|
3631
|
+
severity: "direct",
|
|
3632
|
+
lines: [
|
|
3633
|
+
{ label: "With", after: resource.startsWith("room:") ? `Anyone who joins "${resource.slice(5)}" in this applet` : "One person this applet chose" },
|
|
3634
|
+
{ label: "They learn", after: "Your network address, which can show roughly where you are" },
|
|
3635
|
+
{ label: "They see", after: "Whatever this applet sends them. The shell cannot see it." },
|
|
3636
|
+
{ label: "Introduced by", after: relays2.join(", ") },
|
|
3637
|
+
...helpers.length > 0 ? [{ label: "Helped by", after: helpers.join(", ") }] : [],
|
|
3638
|
+
{ label: "They know you as", after: "A new name for this window, not your account" }
|
|
3639
|
+
],
|
|
3640
|
+
applet,
|
|
3641
|
+
event: draft
|
|
3642
|
+
};
|
|
3643
|
+
}
|
|
3644
|
+
function signalRelayOver(pool) {
|
|
3645
|
+
return {
|
|
3646
|
+
subscribe(relays2, filters, onEvent) {
|
|
3647
|
+
const handle = subscribeWithEose(pool, [...relays2], filters, (item) => {
|
|
3648
|
+
if (item !== "EOSE") onEvent(item);
|
|
3649
|
+
});
|
|
3650
|
+
return { close: () => handle.unsubscribe() };
|
|
3651
|
+
},
|
|
3652
|
+
async publish(relays2, event) {
|
|
3653
|
+
await publishAccepted(pool, [...relays2], event);
|
|
3654
|
+
}
|
|
3655
|
+
};
|
|
3656
|
+
}
|
|
3657
|
+
function createDirectConnectionsService(options) {
|
|
3658
|
+
const windows = /* @__PURE__ */ new Map();
|
|
3659
|
+
const createPeer = options.createPeer ?? ((configuration) => new RTCPeerConnection(configuration));
|
|
3660
|
+
let runtime;
|
|
3661
|
+
const authorize = (lifetime) => async (windowId, _operation, requirements, execute, signal) => {
|
|
3662
|
+
const applet = options.appletOf(windowId);
|
|
3663
|
+
if (!applet || !options.isGranted(windowId)) return { status: "denied" };
|
|
3664
|
+
if (!await options.ask(describeDirectConnection(requirements, applet.identity))) return { status: "denied" };
|
|
3665
|
+
if (lifetime.aborted || signal?.aborted || !options.isGranted(windowId)) return { status: "cancelled" };
|
|
3666
|
+
return { status: "executed", value: await execute(lifetime) };
|
|
3667
|
+
};
|
|
3668
|
+
const windowFor = (windowId) => {
|
|
3669
|
+
let entry = windows.get(windowId);
|
|
3670
|
+
if (!entry) {
|
|
3671
|
+
const lifetime = new AbortController();
|
|
3672
|
+
const applet = options.appletOf(windowId);
|
|
3673
|
+
const helpers = options.iceServers();
|
|
3674
|
+
const configuration = { iceServers: helpers.map((server) => ({ ...server, urls: [...server.urls] })) };
|
|
3675
|
+
const service = createWebrtcService(createDirectSignaling({
|
|
3676
|
+
signer: options.identities.signer(windowId),
|
|
3677
|
+
namespace: applet ? directNamespace(applet) : "",
|
|
3678
|
+
relays: [...options.relays()],
|
|
3679
|
+
relay: signalRelayOver(options.pool),
|
|
3680
|
+
iceEndpoints: helpers.flatMap((server) => server.urls),
|
|
3681
|
+
createPeer: () => createPeer(configuration)
|
|
3682
|
+
}));
|
|
3683
|
+
service.onRegistered?.({ ...runtime, authorizeOperation: authorize(lifetime.signal) });
|
|
3684
|
+
entry = { service, lifetime };
|
|
3685
|
+
windows.set(windowId, entry);
|
|
3686
|
+
}
|
|
3687
|
+
return entry;
|
|
3688
|
+
};
|
|
3689
|
+
const end = (windowId) => {
|
|
3690
|
+
const entry = windows.get(windowId);
|
|
3691
|
+
windows.delete(windowId);
|
|
3692
|
+
entry?.lifetime.abort();
|
|
3693
|
+
entry?.service.onWindowDestroyed?.(windowId);
|
|
3694
|
+
options.identities.release(windowId);
|
|
3695
|
+
};
|
|
3696
|
+
return {
|
|
3697
|
+
descriptor: { name: "webrtc", version: "1.0.0", description: "Direct sessions between people, each window under its own key" },
|
|
3698
|
+
onRegistered(context) {
|
|
3699
|
+
runtime = context;
|
|
3700
|
+
},
|
|
3701
|
+
onUnregistered() {
|
|
3702
|
+
for (const windowId of windows.keys()) end(windowId);
|
|
3703
|
+
runtime = void 0;
|
|
3704
|
+
},
|
|
3705
|
+
handleMessage(windowId, message, send) {
|
|
3706
|
+
windowFor(windowId).service.handleMessage(windowId, message, send);
|
|
3707
|
+
},
|
|
3708
|
+
onWindowDestroyed: end,
|
|
3709
|
+
onPermissionRevoked: end
|
|
3710
|
+
};
|
|
3711
|
+
}
|
|
2915
3712
|
|
|
2916
3713
|
// src/kernl-services.ts
|
|
2917
|
-
import { verifyEvent as
|
|
3714
|
+
import { verifyEvent as verifyEvent6 } from "applesauce-core/helpers";
|
|
2918
3715
|
import {
|
|
3716
|
+
createCommonService,
|
|
3717
|
+
createConfigService,
|
|
2919
3718
|
createDmService,
|
|
2920
3719
|
createIdentityService,
|
|
2921
3720
|
createLinkService,
|
|
2922
3721
|
createNotifyService,
|
|
2923
3722
|
createOutboxService,
|
|
2924
3723
|
createRelayPoolOutboxRouter,
|
|
2925
|
-
createRelayPoolService,
|
|
2926
3724
|
createResourceService,
|
|
2927
3725
|
createThemeService,
|
|
2928
3726
|
createUploadService
|
|
@@ -2931,8 +3729,8 @@ import { createBridgeResourceResolver } from "@kernlize/bridges";
|
|
|
2931
3729
|
function isTheme(value) {
|
|
2932
3730
|
const colors = value?.colors;
|
|
2933
3731
|
if (typeof colors !== "object" || colors === null) return false;
|
|
2934
|
-
const { background, text:
|
|
2935
|
-
return typeof background === "string" && typeof
|
|
3732
|
+
const { background, text: text3, primary } = colors;
|
|
3733
|
+
return typeof background === "string" && typeof text3 === "string" && typeof primary === "string";
|
|
2936
3734
|
}
|
|
2937
3735
|
var LINK_PROTOCOLS = Object.freeze(["https:", "mailto:"]);
|
|
2938
3736
|
function toRelayListEntry(relays2) {
|
|
@@ -2965,11 +3763,16 @@ function resourceInitFor(deps, init) {
|
|
|
2965
3763
|
const requester = requesterFor(deps, init.windowId);
|
|
2966
3764
|
return init.headers ? { signal: init.signal, requester, headers: init.headers } : { signal: init.signal, requester };
|
|
2967
3765
|
}
|
|
2968
|
-
function
|
|
2969
|
-
|
|
2970
|
-
|
|
2971
|
-
|
|
2972
|
-
|
|
3766
|
+
function createIdentitySigner(auth) {
|
|
3767
|
+
let view;
|
|
3768
|
+
return () => {
|
|
3769
|
+
const signer = auth.getSigner();
|
|
3770
|
+
if (signer) return signer;
|
|
3771
|
+
const pubkey = auth.getUserPubkey?.() ?? null;
|
|
3772
|
+
if (pubkey === null) return null;
|
|
3773
|
+
if (view?.pubkey !== pubkey) view = { pubkey, signer: { getPublicKey: () => pubkey } };
|
|
3774
|
+
return view.signer;
|
|
3775
|
+
};
|
|
2973
3776
|
}
|
|
2974
3777
|
function createOutbox(deps, identity) {
|
|
2975
3778
|
const router = createRelayPoolOutboxRouter({
|
|
@@ -2988,7 +3791,7 @@ function createOutbox(deps, identity) {
|
|
|
2988
3791
|
if (!signer?.signEvent) throw new Error("denied:read-only");
|
|
2989
3792
|
return signer.signEvent(template);
|
|
2990
3793
|
},
|
|
2991
|
-
verifyEvent: (event) =>
|
|
3794
|
+
verifyEvent: (event) => verifyEvent6(event)
|
|
2992
3795
|
});
|
|
2993
3796
|
return createOutboxService({ router: acceptAnyRelay(router) });
|
|
2994
3797
|
}
|
|
@@ -3017,9 +3820,12 @@ function createKernlServices(deps) {
|
|
|
3017
3820
|
const composite = deps.messaging.composite();
|
|
3018
3821
|
const dm = createDmService({ adapter: deps.profiles ? labelConversations(composite, deps.profiles) : composite });
|
|
3019
3822
|
const resolve = createBridgeResourceResolver(deps.bridges);
|
|
3823
|
+
const identities = deps.identities ?? createWindowIdentities();
|
|
3824
|
+
const direct = deps.directConnections;
|
|
3825
|
+
const chosen = () => deps.multiplayer?.state();
|
|
3020
3826
|
const registry = {
|
|
3021
|
-
relay:
|
|
3022
|
-
identity: createIdentityService({ getSigner: (
|
|
3827
|
+
relay: createAppletRelayService(deps.pool, deps.tiers),
|
|
3828
|
+
identity: createIdentityService({ getSigner: createIdentitySigner(deps.auth), ...identity }),
|
|
3023
3829
|
theme: theme.handler,
|
|
3024
3830
|
notify: createNotifyService({
|
|
3025
3831
|
present: ({ windowId, message }) => deps.host.notify({ title: message.title, windowId, tone: "info", ...message.body ? { body: message.body } : {} })
|
|
@@ -3032,18 +3838,34 @@ function createKernlServices(deps) {
|
|
|
3032
3838
|
}
|
|
3033
3839
|
}),
|
|
3034
3840
|
resource: createResourceService({
|
|
3035
|
-
fetch: (url, init) => resolve(url, resourceInitFor(deps, init))
|
|
3036
|
-
resolveIdentity: deps.resolveIdentity
|
|
3841
|
+
fetch: (url, init) => resolve(url, resourceInitFor(deps, init))
|
|
3037
3842
|
}),
|
|
3038
3843
|
dm,
|
|
3039
3844
|
outbox: gateOutboxPublish(createOutbox(deps, identity), deps.consent),
|
|
3845
|
+
cvm: createRemoteToolsService({
|
|
3846
|
+
pool: deps.pool,
|
|
3847
|
+
relays: () => chosen()?.servers ?? deps.remoteTools?.relays ?? deps.tiers.get().super,
|
|
3848
|
+
identities,
|
|
3849
|
+
registry: () => mergeFamilies(deps.remoteTools?.registry ?? [], chosen()?.families ?? [])
|
|
3850
|
+
}),
|
|
3851
|
+
...direct ? {
|
|
3852
|
+
webrtc: createDirectConnectionsService({
|
|
3853
|
+
...direct,
|
|
3854
|
+
pool: deps.pool,
|
|
3855
|
+
relays: () => chosen()?.servers ?? direct.settings.relays ?? deps.tiers.get().super,
|
|
3856
|
+
identities,
|
|
3857
|
+
iceServers: () => chosen()?.helpers ?? direct.settings.iceServers ?? []
|
|
3858
|
+
})
|
|
3859
|
+
} : {},
|
|
3860
|
+
...deps.config ? { config: createConfigService(deps.config).handler } : {},
|
|
3861
|
+
...deps.common ? { common: createCommonService(deps.common) } : {},
|
|
3040
3862
|
...deps.uploader ? { upload: createUploadService({ uploader: deps.uploader, uploadInfo: { rails: [{ rail: "blossom", enabled: true }] } }) } : {}
|
|
3041
3863
|
};
|
|
3042
3864
|
return { registry, theme, dm };
|
|
3043
3865
|
}
|
|
3044
3866
|
|
|
3045
3867
|
// src/kernl-adapter.ts
|
|
3046
|
-
import { verifyEvent as
|
|
3868
|
+
import { verifyEvent as verifyEvent7 } from "applesauce-core/helpers";
|
|
3047
3869
|
var TIERS2 = ["discovery", "apps", "outbox", "super"];
|
|
3048
3870
|
var UPLOAD_BACKEND = Object.freeze({ rails: Object.freeze(["blossom"]) });
|
|
3049
3871
|
function isTier(tier) {
|
|
@@ -3073,7 +3895,10 @@ function createShellAdapter(deps) {
|
|
|
3073
3895
|
workerRelay: { getWorkerRelay: () => null },
|
|
3074
3896
|
// kehto offers the upload domain only when both the service and this backend are present; kernl's uploads are Blossom (D-033).
|
|
3075
3897
|
upload: { getUploader: () => deps.services.upload ? UPLOAD_BACKEND : null },
|
|
3076
|
-
|
|
3898
|
+
common: { isAvailable: () => deps.services.common !== void 0 },
|
|
3899
|
+
// kehto offers direct connections only when this says so; kernl registers the service only where the page can make peer connections (D-042).
|
|
3900
|
+
webrtc: { isAvailable: () => deps.services.webrtc !== void 0 },
|
|
3901
|
+
crypto: { verifyEvent: (event) => Promise.resolve(verifyEvent7(event)) },
|
|
3077
3902
|
link: { isAvailable: () => true },
|
|
3078
3903
|
intent: { isAvailable: () => true },
|
|
3079
3904
|
services: deps.services,
|
|
@@ -3089,6 +3914,13 @@ function createShellAdapter(deps) {
|
|
|
3089
3914
|
|
|
3090
3915
|
// src/kernl-lifecycle.ts
|
|
3091
3916
|
import { originRegistry } from "@kehto/shell";
|
|
3917
|
+
function grantNarrowingReason(plan, record2, baseline) {
|
|
3918
|
+
const { identity } = plan.summary;
|
|
3919
|
+
if (record2.identity.dTag !== identity.dTag || record2.identity.hash !== identity.hash) return void 0;
|
|
3920
|
+
if (record2.blocked) return "blocked";
|
|
3921
|
+
const allowed = /* @__PURE__ */ new Set([...baseline, ...record2.domains]);
|
|
3922
|
+
return plan.environment.capabilities.domains.some((domain) => !allowed.has(domain)) ? "grant-narrowed" : void 0;
|
|
3923
|
+
}
|
|
3092
3924
|
function keyOf2(identity) {
|
|
3093
3925
|
return `${identity.dTag}:${identity.hash}`;
|
|
3094
3926
|
}
|
|
@@ -3139,7 +3971,7 @@ function createAppletLifecycle(context) {
|
|
|
3139
3971
|
return planMount({ summary, indexHtml, adapter: context.adapter, guardProfile: pipeline.config.profile, windowId: `applet-${windowCounter}` });
|
|
3140
3972
|
},
|
|
3141
3973
|
mount(plan, frame) {
|
|
3142
|
-
applyRuntimeFirewallRules(
|
|
3974
|
+
applyRuntimeFirewallRules(context.firewall, pipeline.config, plan.summary.identity.dTag);
|
|
3143
3975
|
const handle = mountApplet(plan, frame, {
|
|
3144
3976
|
bridge,
|
|
3145
3977
|
originRegistry,
|
|
@@ -3147,8 +3979,17 @@ function createAppletLifecycle(context) {
|
|
|
3147
3979
|
onRevoked: (windowId, reason) => context.host.onRevoked(windowId, reason)
|
|
3148
3980
|
});
|
|
3149
3981
|
handles.set(plan.windowId, handle);
|
|
3982
|
+
const narrowed = context.grants.changes$.subscribe((record2) => {
|
|
3983
|
+
const reason = grantNarrowingReason(plan, record2, context.grants.baselineDomains());
|
|
3984
|
+
if (!reason) return;
|
|
3985
|
+
handle.revoked(reason);
|
|
3986
|
+
bridge.revokeNapplet(plan.windowId, "host");
|
|
3987
|
+
});
|
|
3988
|
+
context.subscriptions.add(narrowed);
|
|
3150
3989
|
context.subscriptions.add(handle.status$.subscribe((status) => {
|
|
3151
|
-
if (status
|
|
3990
|
+
if (status !== "closed" && status !== "revoked") return;
|
|
3991
|
+
handles.delete(plan.windowId);
|
|
3992
|
+
narrowed.unsubscribe();
|
|
3152
3993
|
}));
|
|
3153
3994
|
return handle;
|
|
3154
3995
|
},
|
|
@@ -3160,7 +4001,7 @@ function createAppletLifecycle(context) {
|
|
|
3160
4001
|
}
|
|
3161
4002
|
|
|
3162
4003
|
// src/kernl.ts
|
|
3163
|
-
import { BehaviorSubject as
|
|
4004
|
+
import { BehaviorSubject as BehaviorSubject9, map as map9, of as of3, Subject as Subject4, Subscription as Subscription2, switchMap as switchMap5 } from "rxjs";
|
|
3164
4005
|
import { EventStore } from "applesauce-core";
|
|
3165
4006
|
import { RelayPool } from "applesauce-relay";
|
|
3166
4007
|
import { buildShellCapabilities, createShellBridge } from "@kehto/shell";
|
|
@@ -3168,12 +4009,11 @@ import { createGuardConfig as createGuardConfig2, describeMitigations } from "@k
|
|
|
3168
4009
|
|
|
3169
4010
|
// src/kernl-intents.ts
|
|
3170
4011
|
import { Subscription } from "rxjs";
|
|
3171
|
-
import { originRegistry as originRegistry2 } from "@kehto/shell";
|
|
3172
4012
|
import { createIntentService } from "@kehto/services";
|
|
3173
4013
|
|
|
3174
4014
|
// src/intents/defaults.ts
|
|
3175
|
-
import { lastValueFrom as
|
|
3176
|
-
import { verifyEvent as
|
|
4015
|
+
import { lastValueFrom as lastValueFrom9, Subject as Subject3, takeUntil as takeUntil4, timer as timer6, toArray as toArray6 } from "rxjs";
|
|
4016
|
+
import { verifyEvent as verifyEvent8 } from "applesauce-core/helpers";
|
|
3177
4017
|
|
|
3178
4018
|
// src/intents/preferences.ts
|
|
3179
4019
|
var HANDLER_PREFERENCES_KIND = 31129;
|
|
@@ -3245,7 +4085,7 @@ function preferenceRelays(tiers) {
|
|
|
3245
4085
|
function newestPerArchetype(events, pubkey) {
|
|
3246
4086
|
const newest2 = /* @__PURE__ */ new Map();
|
|
3247
4087
|
for (const event of events) {
|
|
3248
|
-
if (event.kind !== HANDLER_PREFERENCES_KIND || event.pubkey !== pubkey || !
|
|
4088
|
+
if (event.kind !== HANDLER_PREFERENCES_KIND || event.pubkey !== pubkey || !verifyEvent8(event)) continue;
|
|
3249
4089
|
const archetype = event.tags.find((tag) => tag[0] === "d")?.[1] ?? "";
|
|
3250
4090
|
const current = newest2.get(archetype);
|
|
3251
4091
|
if (archetype && (!current || event.created_at > current.created_at)) newest2.set(archetype, event);
|
|
@@ -3288,7 +4128,7 @@ function createHandlerDefaults(options) {
|
|
|
3288
4128
|
loadedFor = pubkey;
|
|
3289
4129
|
if (!pubkey) return;
|
|
3290
4130
|
const request = options.pool.request([...preferenceRelays(options.tiers)], asFilters([{ kinds: [HANDLER_PREFERENCES_KIND], authors: [pubkey] }]));
|
|
3291
|
-
const events = await
|
|
4131
|
+
const events = await lastValueFrom9(request.pipe(takeUntil4(timer6(LOAD_TIMEOUT_MS)), toArray6()), { defaultValue: [] }).catch(() => []);
|
|
3292
4132
|
for (const [archetype, event] of newestPerArchetype(events, pubkey)) {
|
|
3293
4133
|
published.set(archetype, event);
|
|
3294
4134
|
changes$.next(archetype);
|
|
@@ -3333,9 +4173,9 @@ function createIntentDelivery(options) {
|
|
|
3333
4173
|
}
|
|
3334
4174
|
|
|
3335
4175
|
// src/intents/installed.ts
|
|
3336
|
-
import { BehaviorSubject as
|
|
4176
|
+
import { BehaviorSubject as BehaviorSubject8 } from "rxjs";
|
|
3337
4177
|
import { manifestToIntentCatalogEntry } from "@kehto/services";
|
|
3338
|
-
var
|
|
4178
|
+
var STORAGE_KEY6 = "installed:v1";
|
|
3339
4179
|
function isInstalled(value) {
|
|
3340
4180
|
if (typeof value !== "object" || value === null) return false;
|
|
3341
4181
|
const row = value;
|
|
@@ -3355,10 +4195,10 @@ function toCatalogEntry2(applet) {
|
|
|
3355
4195
|
}
|
|
3356
4196
|
function createInstalledApplets(storage, now = Date.now) {
|
|
3357
4197
|
const store = createNamespacedStore(storage, "kernl");
|
|
3358
|
-
const stored = store.getJson(
|
|
3359
|
-
const changes$ = new
|
|
4198
|
+
const stored = store.getJson(STORAGE_KEY6, []);
|
|
4199
|
+
const changes$ = new BehaviorSubject8(Object.freeze(Array.isArray(stored) ? stored.filter(isInstalled) : []));
|
|
3360
4200
|
const commit = (next) => {
|
|
3361
|
-
store.setJson(
|
|
4201
|
+
store.setJson(STORAGE_KEY6, next);
|
|
3362
4202
|
changes$.next(Object.freeze([...next]));
|
|
3363
4203
|
};
|
|
3364
4204
|
return {
|
|
@@ -3512,10 +4352,9 @@ function createKernlIntents(deps) {
|
|
|
3512
4352
|
findWindow: (catalogId) => [...handles.values()].find((handle) => handle.summary.manifest.catalogId === catalogId)?.windowId,
|
|
3513
4353
|
openApplet: async (address) => host.openApplet?.(address),
|
|
3514
4354
|
...host.focusApplet ? { focus: host.focusApplet.bind(host) } : {},
|
|
3515
|
-
//
|
|
3516
|
-
//
|
|
3517
|
-
|
|
3518
|
-
send: (windowId, message) => context?.hasCapability(windowId, "intent:read") === true && originRegistry2.postToNapplet(windowId, message),
|
|
4355
|
+
// The runtime's recipient gate maps `intent.deliver` to `intent:read` since @kehto/acl 0.20.6,
|
|
4356
|
+
// so delivery goes through it to a live, unblocked, granted target (DECISIONS.md D-037).
|
|
4357
|
+
send: (windowId, message) => context?.sendToEligibleNapplet(windowId, message) === true,
|
|
3519
4358
|
...deps.retry ? { retry: deps.retry } : {}
|
|
3520
4359
|
});
|
|
3521
4360
|
const router = createIntentRouter({
|
|
@@ -3551,7 +4390,7 @@ function createKernlIntents(deps) {
|
|
|
3551
4390
|
}
|
|
3552
4391
|
|
|
3553
4392
|
// src/catalog/fetch.ts
|
|
3554
|
-
import { auditTime as auditTime2, catchError as catchError4, EMPTY as EMPTY4, from, lastValueFrom as
|
|
4393
|
+
import { auditTime as auditTime2, catchError as catchError4, EMPTY as EMPTY4, from, lastValueFrom as lastValueFrom10, map as map8, merge as merge4, mergeAll, scan, share as share2, takeUntil as takeUntil5, tap, timer as timer7 } from "rxjs";
|
|
3555
4394
|
import { getSeenRelays } from "applesauce-core/helpers";
|
|
3556
4395
|
import { NAPPLET_KIND_NAMED, NAPPLET_KIND_ROOT } from "@kehto/nip/5d";
|
|
3557
4396
|
|
|
@@ -3601,7 +4440,7 @@ function streamCatalog(pool, tiers, options = {}) {
|
|
|
3601
4440
|
const filters = asFilters(catalogFilters(options));
|
|
3602
4441
|
const cached = options.cache ? from(options.cache(filters).catch(() => [])).pipe(mergeAll()) : EMPTY4;
|
|
3603
4442
|
const live = pool.request([...relays2], filters).pipe(
|
|
3604
|
-
|
|
4443
|
+
takeUntil5(timer7(options.timeoutMs ?? CATALOG_TIMEOUT_MS)),
|
|
3605
4444
|
catchError4(() => EMPTY4),
|
|
3606
4445
|
tap((event) => options.store?.add(event))
|
|
3607
4446
|
);
|
|
@@ -3615,11 +4454,11 @@ function streamCatalog(pool, tiers, options = {}) {
|
|
|
3615
4454
|
);
|
|
3616
4455
|
const listed = (state) => newestEntries(state.listed.filter(({ event }) => !isWithdrawn(event, state.withdrawn)).map(({ entry }) => entry));
|
|
3617
4456
|
const lists = found.pipe(auditTime2(options.emitMs ?? CATALOG_EMIT_MS), map8(listed), share2());
|
|
3618
|
-
const nothingYet =
|
|
4457
|
+
const nothingYet = timer7(options.settleMs ?? CATALOG_SETTLE_MS).pipe(map8(() => Object.freeze([])), takeUntil5(lists));
|
|
3619
4458
|
return merge4(nothingYet, lists);
|
|
3620
4459
|
}
|
|
3621
4460
|
async function loadCatalog(pool, tiers, options = {}) {
|
|
3622
|
-
return
|
|
4461
|
+
return lastValueFrom10(streamCatalog(pool, tiers, options), { defaultValue: Object.freeze([]) });
|
|
3623
4462
|
}
|
|
3624
4463
|
|
|
3625
4464
|
// src/kernl.ts
|
|
@@ -3629,11 +4468,11 @@ function toSession(account, card) {
|
|
|
3629
4468
|
const label = named ?? (card?.found ? card.name : abbreviate(account.pubkey));
|
|
3630
4469
|
return { accountId: account.id, pubkey: account.pubkey, label, readOnly: isReadOnlyAccount(account) };
|
|
3631
4470
|
}
|
|
3632
|
-
function followShellState({ pipeline, bridge, handles, accounts, session$, profiles, mailboxes, tiers }) {
|
|
4471
|
+
function followShellState({ pipeline, firewall, bridge, handles, accounts, session$, profiles, mailboxes, tiers }) {
|
|
3633
4472
|
const subscriptions = new Subscription2();
|
|
3634
4473
|
subscriptions.add(pipeline.profile$.subscribe(() => {
|
|
3635
|
-
applyRuntimeFirewallProfile(
|
|
3636
|
-
for (const handle of handles.values()) applyRuntimeFirewallRules(
|
|
4474
|
+
applyRuntimeFirewallProfile(firewall, pipeline.config);
|
|
4475
|
+
for (const handle of handles.values()) applyRuntimeFirewallRules(firewall, pipeline.config, handle.summary.identity.dTag);
|
|
3637
4476
|
}));
|
|
3638
4477
|
subscriptions.add(accounts.active$.subscribe((account) => bridge.publishIdentityChanged(account?.pubkey ?? "")));
|
|
3639
4478
|
const sessions = accounts.active$.pipe(switchMap5((account) => account ? profiles.card$(account.pubkey).pipe(map9((card) => toSession(account, card))) : of3(null)));
|
|
@@ -3699,8 +4538,43 @@ function registriesFor(options, parts) {
|
|
|
3699
4538
|
bridges: options.bridges ?? createDefaultBridges({ handoff: (uri) => host.openLink(uri), ...options.torrent ? { torrent: options.torrent } : {} })
|
|
3700
4539
|
};
|
|
3701
4540
|
}
|
|
4541
|
+
function meetingFor(options, parts) {
|
|
4542
|
+
const settings = createMultiplayerSettings(options.host.storage);
|
|
4543
|
+
const relays2 = () => settings.state().servers ?? options.remoteTools?.relays ?? parts.tiers.get().super;
|
|
4544
|
+
const multiplayer = { ...settings, discover: (input) => discoverToolFamilies(input, { pool: parts.pool, relays: relays2(), fetch: globalThis.fetch.bind(globalThis) }) };
|
|
4545
|
+
return {
|
|
4546
|
+
deps: { identities: createWindowIdentities(), remoteTools: options.remoteTools, directConnections: directConnectionsFor(options, parts.appletOf, parts.grants), multiplayer },
|
|
4547
|
+
multiplayer
|
|
4548
|
+
};
|
|
4549
|
+
}
|
|
4550
|
+
function uploaderFor(host, files, signer, identityOf) {
|
|
4551
|
+
return createBlossomUploader({
|
|
4552
|
+
servers: () => files.current(),
|
|
4553
|
+
signer,
|
|
4554
|
+
ask: (windowId, details) => askUploadConsent(host, identityOf(windowId), details)
|
|
4555
|
+
});
|
|
4556
|
+
}
|
|
4557
|
+
function directConnectionsFor(options, appletOf2, grants) {
|
|
4558
|
+
const { createPeer, ...settings } = options.directConnections ?? {};
|
|
4559
|
+
if (!createPeer && typeof RTCPeerConnection !== "function") return void 0;
|
|
4560
|
+
return {
|
|
4561
|
+
settings,
|
|
4562
|
+
...createPeer ? { createPeer } : {},
|
|
4563
|
+
appletOf: appletOf2,
|
|
4564
|
+
isGranted(windowId) {
|
|
4565
|
+
const identity = appletOf2(windowId)?.identity;
|
|
4566
|
+
const record2 = identity && grants().get(identity);
|
|
4567
|
+
return !!record2 && !record2.blocked && record2.domains.includes("webrtc");
|
|
4568
|
+
},
|
|
4569
|
+
ask: (summary) => new Promise((resolve) => options.host.presentConsent({ summary, resolve }))
|
|
4570
|
+
};
|
|
4571
|
+
}
|
|
4572
|
+
function appletOf(handles, windowId) {
|
|
4573
|
+
const summary = handles.get(windowId)?.summary;
|
|
4574
|
+
return summary && { key: summary.manifest.catalogId, title: summary.title };
|
|
4575
|
+
}
|
|
3702
4576
|
function tearDown(parts) {
|
|
3703
|
-
for (const handle of
|
|
4577
|
+
for (const handle of parts.handles.values()) handle.close();
|
|
3704
4578
|
parts.subscriptions.unsubscribe();
|
|
3705
4579
|
parts.destroyed$.next();
|
|
3706
4580
|
parts.network.directory.stop();
|
|
@@ -3716,13 +4590,13 @@ function createKernl(options) {
|
|
|
3716
4590
|
const ownsPool = !options.pool;
|
|
3717
4591
|
const ownsMessaging = !options.messaging;
|
|
3718
4592
|
const eventStore = options.eventStore ?? new EventStore();
|
|
3719
|
-
const pool = options.pool ?? new RelayPool();
|
|
4593
|
+
const pool = options.pool ?? new RelayPool(SHELL_RELAY_OPTIONS);
|
|
3720
4594
|
const accounts = options.accounts ?? createKernlAccounts(host.storage);
|
|
3721
4595
|
const tiers = createRelayTiers(host.storage, options.relays ?? {});
|
|
3722
4596
|
const { messaging, bridges } = registriesFor(options, { eventStore, pool, tiers, accounts });
|
|
3723
4597
|
const handles = /* @__PURE__ */ new Map();
|
|
3724
4598
|
const guardEvents$ = new Subject4();
|
|
3725
|
-
const session$ = new
|
|
4599
|
+
const session$ = new BehaviorSubject9(null);
|
|
3726
4600
|
const destroyed$ = new Subject4();
|
|
3727
4601
|
const subscriptions = new Subscription2();
|
|
3728
4602
|
let grants;
|
|
@@ -3744,6 +4618,7 @@ function createKernl(options) {
|
|
|
3744
4618
|
relays: () => [...tiers.get().outbox, ...tiers.get().discovery]
|
|
3745
4619
|
});
|
|
3746
4620
|
const consent = createSigningConsent({ host, lookupBefore, resolveApplet: identityOf, pubkey: () => accounts.active?.pubkey });
|
|
4621
|
+
const meeting = meetingFor(options, { pool, tiers, appletOf: (windowId) => handles.get(windowId)?.summary, grants: () => grants });
|
|
3747
4622
|
const services = createKernlServices({
|
|
3748
4623
|
pool,
|
|
3749
4624
|
tiers,
|
|
@@ -3754,12 +4629,11 @@ function createKernl(options) {
|
|
|
3754
4629
|
bridges,
|
|
3755
4630
|
messaging,
|
|
3756
4631
|
profiles,
|
|
3757
|
-
|
|
3758
|
-
|
|
3759
|
-
|
|
3760
|
-
ask: (windowId, details) => askUploadConsent(host, identityOf(windowId), details)
|
|
3761
|
-
}),
|
|
4632
|
+
...host.presentSettings ? { config: createAppletConfig({ storage: host.storage, appletOf: (windowId) => appletOf(handles, windowId), present: host.presentSettings.bind(host) }) } : {},
|
|
4633
|
+
common: commonActionsFor({ eventStore, pool, tiers, accounts }, { profiles, replaceableLoader, signer }, consent),
|
|
4634
|
+
uploader: uploaderFor(host, files, signer, identityOf),
|
|
3762
4635
|
...isTheme(options.theme) ? { theme: options.theme } : {},
|
|
4636
|
+
...meeting.deps,
|
|
3763
4637
|
resolveIdentity(windowId) {
|
|
3764
4638
|
const identity = identityOf(windowId);
|
|
3765
4639
|
return identity ? { dTag: identity.dTag, aggregateHash: identity.hash } : null;
|
|
@@ -3767,6 +4641,11 @@ function createKernl(options) {
|
|
|
3767
4641
|
});
|
|
3768
4642
|
const intents = createKernlIntents({ host, pool, tiers, accounts, handles, ...options.intentRetry ? { retry: options.intentRetry } : {} });
|
|
3769
4643
|
services.registry.intent = intents.handler;
|
|
4644
|
+
const runtimeFirewall = createRuntimeFirewallHooks({
|
|
4645
|
+
storage: host.storage,
|
|
4646
|
+
onEvent: (event) => guardEvents$.next(event),
|
|
4647
|
+
...host.now ? { now: host.now.bind(host) } : {}
|
|
4648
|
+
});
|
|
3770
4649
|
const adapter = createShellAdapter({
|
|
3771
4650
|
pool,
|
|
3772
4651
|
tiers,
|
|
@@ -3777,22 +4656,19 @@ function createKernl(options) {
|
|
|
3777
4656
|
onNappletRevoked: ({ windowId, reason }) => handles.get(windowId)?.revoked(reason),
|
|
3778
4657
|
filterNappletMessage: (windowId, message) => pipeline.observe(windowId, identityOf(windowId)?.dTag ?? "unknown", message),
|
|
3779
4658
|
getFocusContext: (windowId) => ({ focused: pipeline.getVisibility(windowId).focused }),
|
|
3780
|
-
runtimeFirewall
|
|
3781
|
-
storage: host.storage,
|
|
3782
|
-
onEvent: (event) => guardEvents$.next(event),
|
|
3783
|
-
...host.now ? { now: host.now.bind(host) } : {}
|
|
3784
|
-
})
|
|
4659
|
+
runtimeFirewall
|
|
3785
4660
|
});
|
|
3786
4661
|
const bridge = createShellBridge(adapter);
|
|
3787
4662
|
grants = createGrants({ acl: bridge.runtime.aclState, storage: host.storage, availableDomains: () => buildShellCapabilities(adapter).domains });
|
|
3788
4663
|
bridge.registerConsentHandler(createConsentHandler(host, lookupBefore, identityOf));
|
|
3789
|
-
subscriptions.add(followShellState({ pipeline, bridge, handles, accounts, session$, profiles, mailboxes, tiers }));
|
|
4664
|
+
subscriptions.add(followShellState({ pipeline, firewall: runtimeFirewall.legacyFirewall, bridge, handles, accounts, session$, profiles, mailboxes, tiers }));
|
|
3790
4665
|
const lifecycle = createAppletLifecycle({
|
|
3791
4666
|
pool,
|
|
3792
4667
|
tiers,
|
|
3793
4668
|
adapter,
|
|
3794
4669
|
bridge,
|
|
3795
4670
|
pipeline,
|
|
4671
|
+
firewall: runtimeFirewall.legacyFirewall,
|
|
3796
4672
|
grants,
|
|
3797
4673
|
installed: intents.installed,
|
|
3798
4674
|
host,
|
|
@@ -3819,6 +4695,7 @@ function createKernl(options) {
|
|
|
3819
4695
|
profiles,
|
|
3820
4696
|
mailboxes,
|
|
3821
4697
|
files,
|
|
4698
|
+
multiplayer: meeting.multiplayer,
|
|
3822
4699
|
directory,
|
|
3823
4700
|
intents: intents.intents,
|
|
3824
4701
|
session$,
|
|
@@ -3861,8 +4738,8 @@ function wordScore(word, entry) {
|
|
|
3861
4738
|
}
|
|
3862
4739
|
return best;
|
|
3863
4740
|
}
|
|
3864
|
-
function textScore(
|
|
3865
|
-
const words =
|
|
4741
|
+
function textScore(text3, entry) {
|
|
4742
|
+
const words = text3.toLowerCase().split(/\s+/).filter(Boolean);
|
|
3866
4743
|
let total = 0;
|
|
3867
4744
|
for (const word of words) {
|
|
3868
4745
|
const score = wordScore(word, entry);
|
|
@@ -3871,16 +4748,16 @@ function textScore(text2, entry) {
|
|
|
3871
4748
|
}
|
|
3872
4749
|
return words.length === 0 ? 1 : total;
|
|
3873
4750
|
}
|
|
3874
|
-
function passesFilters(entry,
|
|
3875
|
-
if (
|
|
3876
|
-
if (
|
|
3877
|
-
return
|
|
4751
|
+
function passesFilters(entry, query2) {
|
|
4752
|
+
if (query2.topics?.some((topic) => !entry.topics.includes(topic))) return false;
|
|
4753
|
+
if (query2.available && entry.requires.some((domain) => !query2.available?.includes(domain))) return false;
|
|
4754
|
+
return query2.convention === void 0 || entry.conventions.includes(query2.convention);
|
|
3878
4755
|
}
|
|
3879
|
-
function searchCatalog(entries,
|
|
4756
|
+
function searchCatalog(entries, query2 = {}) {
|
|
3880
4757
|
const scored = [];
|
|
3881
4758
|
for (const entry of entries) {
|
|
3882
|
-
if (!passesFilters(entry,
|
|
3883
|
-
const score = textScore(
|
|
4759
|
+
if (!passesFilters(entry, query2)) continue;
|
|
4760
|
+
const score = textScore(query2.text ?? "", entry);
|
|
3884
4761
|
if (score > 0) scored.push({ entry, score });
|
|
3885
4762
|
}
|
|
3886
4763
|
scored.sort((a, b) => b.score - a.score || b.entry.publishedAt - a.entry.publishedAt);
|
|
@@ -3912,6 +4789,9 @@ export {
|
|
|
3912
4789
|
DEFAULT_RELAY_TIERS,
|
|
3913
4790
|
DEFAULT_SUGGESTIONS,
|
|
3914
4791
|
DELIVERY_RETRY,
|
|
4792
|
+
DIRECT_MAX_PAYLOAD_BYTES,
|
|
4793
|
+
DIRECT_SIGNALING_PROFILE,
|
|
4794
|
+
DIRECT_SIGNAL_KIND,
|
|
3915
4795
|
DOMAIN_CAPABILITIES,
|
|
3916
4796
|
HANDLER_PREFERENCES_KIND,
|
|
3917
4797
|
KERNL_FRAME_POLICY_META,
|
|
@@ -3923,6 +4803,8 @@ export {
|
|
|
3923
4803
|
PLAINTEXT_KEY_ACCOUNT_TYPES,
|
|
3924
4804
|
RUNTIME_FIREWALL_STORAGE_KEY,
|
|
3925
4805
|
RUNTIME_OP_CLASSES,
|
|
4806
|
+
SHELL_RELAY_OPTIONS,
|
|
4807
|
+
TOOL_DISCOVERY_TIMEOUT_MS,
|
|
3926
4808
|
UNKNOWN_CURRENT_VERSION,
|
|
3927
4809
|
abbreviate,
|
|
3928
4810
|
addressOf,
|
|
@@ -3935,18 +4817,25 @@ export {
|
|
|
3935
4817
|
capabilitiesForDomains,
|
|
3936
4818
|
catalogIdForRef,
|
|
3937
4819
|
catalogRelays,
|
|
4820
|
+
commonActionsFor,
|
|
3938
4821
|
connectEventCache,
|
|
3939
4822
|
createAccountFileServers,
|
|
3940
4823
|
createAccountMailboxes,
|
|
4824
|
+
createAppletConfig,
|
|
3941
4825
|
createAppletLifecycle,
|
|
3942
4826
|
createAppletRelayBackend,
|
|
4827
|
+
createAppletRelayService,
|
|
3943
4828
|
createAuthHooks,
|
|
3944
4829
|
createBlossomUploader,
|
|
3945
4830
|
createColumnsLayout,
|
|
4831
|
+
createCommonActions,
|
|
3946
4832
|
createConsentHandler,
|
|
4833
|
+
createCvmRelayPool,
|
|
3947
4834
|
createDefaultBridges,
|
|
3948
4835
|
createDefaultLayouts,
|
|
3949
4836
|
createDefaultMessaging,
|
|
4837
|
+
createDirectConnectionsService,
|
|
4838
|
+
createDirectSignaling,
|
|
3950
4839
|
createDmRelayPool,
|
|
3951
4840
|
createDwindleLayout,
|
|
3952
4841
|
createEnvironmentResolver,
|
|
@@ -3971,6 +4860,7 @@ export {
|
|
|
3971
4860
|
createLegacyMessagesBackend,
|
|
3972
4861
|
createMasterStackLayout,
|
|
3973
4862
|
createMemoryCacheAdapter,
|
|
4863
|
+
createMultiplayerSettings,
|
|
3974
4864
|
createNamespacedStore,
|
|
3975
4865
|
createOutboxRelayPool,
|
|
3976
4866
|
createPrivateMessagesBackend,
|
|
@@ -3980,6 +4870,7 @@ export {
|
|
|
3980
4870
|
createRelayPoolHooks,
|
|
3981
4871
|
createRelayPoolLike,
|
|
3982
4872
|
createRelayTiers,
|
|
4873
|
+
createRemoteToolsService,
|
|
3983
4874
|
createReplaceableLoader,
|
|
3984
4875
|
createRuntimeFirewallHooks,
|
|
3985
4876
|
createSealedGroupStore,
|
|
@@ -3987,19 +4878,24 @@ export {
|
|
|
3987
4878
|
createShellAdapter,
|
|
3988
4879
|
createSigningConsent,
|
|
3989
4880
|
createSqliteOpfsCacheAdapter,
|
|
4881
|
+
createWindowIdentities,
|
|
3990
4882
|
createWindowManager,
|
|
3991
4883
|
decodePointer,
|
|
3992
4884
|
defaultFetchBlob,
|
|
3993
4885
|
defaultWebCacheAdapters,
|
|
3994
4886
|
describeChange,
|
|
4887
|
+
describeDirectConnection,
|
|
3995
4888
|
describeOutcome,
|
|
3996
4889
|
describeUpload,
|
|
4890
|
+
directNamespace,
|
|
4891
|
+
discoverToolFamilies,
|
|
3997
4892
|
fetchManifestEvent,
|
|
3998
4893
|
fileServerTags,
|
|
3999
4894
|
fileServersFromEvent,
|
|
4000
4895
|
floatingLayout,
|
|
4001
4896
|
fromEventDatabase,
|
|
4002
4897
|
fuzzyScore,
|
|
4898
|
+
grantNarrowingReason,
|
|
4003
4899
|
installCryptoFallback,
|
|
4004
4900
|
isCorruptionError,
|
|
4005
4901
|
isDestructiveKind,
|
|
@@ -4011,6 +4907,7 @@ export {
|
|
|
4011
4907
|
lookupReplaceable,
|
|
4012
4908
|
mailboxTags,
|
|
4013
4909
|
mailboxesFromEvent,
|
|
4910
|
+
mergeFamilies,
|
|
4014
4911
|
messagingSigner,
|
|
4015
4912
|
mountApplet,
|
|
4016
4913
|
newestEntries,
|
|
@@ -4045,6 +4942,7 @@ export {
|
|
|
4045
4942
|
toProfileCard,
|
|
4046
4943
|
toRelayUrl,
|
|
4047
4944
|
toSession,
|
|
4945
|
+
validFamily,
|
|
4048
4946
|
wrapAccountSigner
|
|
4049
4947
|
};
|
|
4050
4948
|
//# sourceMappingURL=index.js.map
|