@kernlize/core 0.10.0 → 0.12.0

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