@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.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() {
@@ -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 signer = wrapAccountSigner(account);
661
- if (windowId === void 0) return signer;
662
- return {
663
- ...signer,
664
- async signEvent(template) {
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(text2) {
796
- const id = ADDRESS.exec(text2)?.[1];
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(text2) {
800
- const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text2));
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 text2 = input.trim().replace(/^nostr:/i, "");
878
- const builtin = decodeBuiltin(text2);
917
+ const text3 = input.trim().replace(/^nostr:/i, "");
918
+ const builtin = decodeBuiltin(text3);
879
919
  if (builtin) return builtin;
880
- if (HEX_64.test(text2)) return { kind: "event", id: text2, relays: Object.freeze([]) };
881
- const coordinate2 = COORDINATE.exec(text2);
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(text2);
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(text2)?.[0] ?? text2).toLowerCase()) ?? invalid();
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
- async function askOnce(pool, relays2, filter3, waits) {
968
- const request = pool.request(relays2, asFilters([filter3]), { complete: settleManifestRequest(waits), timeout: waits.timeoutMs });
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: true };
973
- } catch (error) {
974
- return { answered: false, refused: error.name !== "TimeoutError" };
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(answered ? "unavailable:manifest" : "unavailable:network");
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(text2, find, replacement) {
1053
- const at = text2.indexOf(find);
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 `${text2.slice(0, at)}${replacement}${text2.slice(at + find.length)}`;
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 record = typeof data === "object" && data !== null ? data : {};
1157
- const event = typeof record.event === "object" && record.event !== null ? record.event : {};
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 record.type === "string" ? record.type : "unknown",
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
- firewallPersistence: {
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 record(entry) {
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 = record(entry);
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(record),
1488
+ list: () => [...records.values()].map(record2),
1434
1489
  get: (identity) => {
1435
1490
  const entry = records.get(keyOf(identity));
1436
- return entry ? record(entry) : void 0;
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 record = grants.get({ dTag: identity.dTag, hash: identity.aggregateHash });
1463
- const allowed = new Set(record?.blocked ? ["shell"] : [...grants.baselineDomains(), ...record?.domains ?? []]);
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(query = {}) {
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, query.cursor, query.limit ?? DEFAULT_CONVERSATION_LIMIT);
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(query) {
1875
- const all = threads.get(query.conversationId)?.messages ?? [];
1876
- const result = page(all, query.cursor, query.limit ?? DEFAULT_MESSAGE_LIMIT);
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(query) {
2046
+ async conversations(query2) {
1992
2047
  await sync();
1993
- return store.conversations(query);
2048
+ return store.conversations(query2);
1994
2049
  },
1995
- async messages(query) {
2050
+ async messages(query2) {
1996
2051
  await sync();
1997
- return store.messages(query);
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(text2) {
2161
+ function chunks(text3) {
2107
2162
  const parts = [];
2108
- for (let start = 0; start < text2.length; start += CHUNK_UNITS) parts.push(text2.slice(start, start + CHUNK_UNITS));
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 signed = await sign(event);
2193
- const results = await options.pool.publish(relays2(), signed).catch(() => []);
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 signed;
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(query) {
2323
+ async conversations(query2) {
2269
2324
  await sync();
2270
- return store.conversations(query);
2325
+ return store.conversations(query2);
2271
2326
  },
2272
- async messages(query) {
2327
+ async messages(query2) {
2273
2328
  await sync();
2274
- return store.messages(query);
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 text2 = JSON.stringify(Object.fromEntries(entries), encode);
2427
+ const text3 = JSON.stringify(Object.fromEntries(entries), encode);
2373
2428
  const parts = [];
2374
- for (let start = 0; start < text2.length; start += SEAL_UNITS) parts.push(text2.slice(start, start + SEAL_UNITS));
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(query) {
2630
+ async conversations(query2) {
2576
2631
  await sync();
2577
- return store.conversations(query);
2632
+ return store.conversations(query2);
2578
2633
  },
2579
- async messages(query) {
2634
+ async messages(query2) {
2580
2635
  await sync();
2581
- return store.messages(query);
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(query) {
2652
- const page2 = await adapter.conversations(query);
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 getProfileContent2, getProfilePicture } from "applesauce-core/helpers";
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 ? getProfileContent2(event) : void 0;
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 verifyEvent4 } from "applesauce-core/helpers";
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: text2, primary } = colors;
2935
- return typeof background === "string" && typeof text2 === "string" && typeof primary === "string";
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 identitySigner(auth) {
2969
- const signer = auth.getSigner();
2970
- if (signer) return signer;
2971
- const pubkey = auth.getUserPubkey?.() ?? null;
2972
- return pubkey === null ? null : { getPublicKey: () => pubkey };
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) => verifyEvent4(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: createRelayPoolService(createAppletRelayBackend(deps.pool, deps.tiers)),
3022
- identity: createIdentityService({ getSigner: () => identitySigner(deps.auth), ...identity }),
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 verifyEvent5 } from "applesauce-core/helpers";
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
- crypto: { verifyEvent: (event) => Promise.resolve(verifyEvent5(event)) },
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(bridge.runtime.firewallState, pipeline.config, plan.summary.identity.dTag);
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 === "closed" || status === "revoked") handles.delete(plan.windowId);
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 BehaviorSubject8, map as map9, of as of3, Subject as Subject4, Subscription as Subscription2, switchMap as switchMap5 } from "rxjs";
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 lastValueFrom7, Subject as Subject3, takeUntil as takeUntil3, timer as timer5, toArray as toArray5 } from "rxjs";
3176
- import { verifyEvent as verifyEvent6 } from "applesauce-core/helpers";
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 || !verifyEvent6(event)) continue;
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 lastValueFrom7(request.pipe(takeUntil3(timer5(LOAD_TIMEOUT_MS)), toArray5()), { defaultValue: [] }).catch(() => []);
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 BehaviorSubject7 } from "rxjs";
4176
+ import { BehaviorSubject as BehaviorSubject8 } from "rxjs";
3337
4177
  import { manifestToIntentCatalogEntry } from "@kehto/services";
3338
- var STORAGE_KEY4 = "installed:v1";
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(STORAGE_KEY4, []);
3359
- const changes$ = new BehaviorSubject7(Object.freeze(Array.isArray(stored) ? stored.filter(isInstalled) : []));
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(STORAGE_KEY4, next);
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
- // kehto's ACL gives `intent.deliver` no recipient capability, so the runtime's recipient-checked
3516
- // send refuses it. Like kehto's own Paja host, the delivery goes over the target's bound port,
3517
- // and only to a live session that holds the receiving grant (DECISIONS.md D-026).
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 lastValueFrom8, map as map8, merge as merge4, mergeAll, scan, share as share2, takeUntil as takeUntil4, tap, timer as timer6 } from "rxjs";
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
- takeUntil4(timer6(options.timeoutMs ?? CATALOG_TIMEOUT_MS)),
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 = timer6(options.settleMs ?? CATALOG_SETTLE_MS).pipe(map8(() => Object.freeze([])), takeUntil4(lists));
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 lastValueFrom8(streamCatalog(pool, tiers, options), { defaultValue: Object.freeze([]) });
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(bridge.runtime.firewallState, pipeline.config);
3636
- for (const handle of handles.values()) applyRuntimeFirewallRules(bridge.runtime.firewallState, pipeline.config, handle.summary.identity.dTag);
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 [...parts.handles.values()]) handle.close();
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 BehaviorSubject8(null);
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
- uploader: createBlossomUploader({
3758
- servers: () => files.current(),
3759
- signer,
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: createRuntimeFirewallHooks({
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(text2, entry) {
3865
- const words = text2.toLowerCase().split(/\s+/).filter(Boolean);
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, query) {
3875
- if (query.topics?.some((topic) => !entry.topics.includes(topic))) return false;
3876
- if (query.available && entry.requires.some((domain) => !query.available?.includes(domain))) return false;
3877
- return query.convention === void 0 || entry.conventions.includes(query.convention);
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, query = {}) {
4756
+ function searchCatalog(entries, query2 = {}) {
3880
4757
  const scored = [];
3881
4758
  for (const entry of entries) {
3882
- if (!passesFilters(entry, query)) continue;
3883
- const score = textScore(query.text ?? "", entry);
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