@kernlize/core 0.10.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() {
@@ -832,12 +832,12 @@ var MANIFEST_KIND = 35129;
832
832
  function builtinAddress(id) {
833
833
  return `kernl:${id}`;
834
834
  }
835
- function decodeBuiltin(text2) {
836
- const id = ADDRESS.exec(text2)?.[1];
835
+ function decodeBuiltin(text3) {
836
+ const id = ADDRESS.exec(text3)?.[1];
837
837
  return id === void 0 ? void 0 : { kind: "builtin", id, relays: Object.freeze([]) };
838
838
  }
839
- async function sha256Hex(text2) {
840
- 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));
841
841
  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
842
842
  }
843
843
  function manifestOf(applet) {
@@ -914,15 +914,15 @@ function fromBech32(input) {
914
914
  return void 0;
915
915
  }
916
916
  function decodePointer(input) {
917
- const text2 = input.trim().replace(/^nostr:/i, "");
918
- const builtin = decodeBuiltin(text2);
917
+ const text3 = input.trim().replace(/^nostr:/i, "");
918
+ const builtin = decodeBuiltin(text3);
919
919
  if (builtin) return builtin;
920
- if (HEX_64.test(text2)) return { kind: "event", id: text2, relays: Object.freeze([]) };
921
- 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);
922
922
  if (coordinate2) return fromCoordinate(coordinate2[1], coordinate2[2], coordinate2[3]);
923
- const aTag = A_TAG_COORDINATE.exec(text2);
923
+ const aTag = A_TAG_COORDINATE.exec(text3);
924
924
  if (aTag) return fromCoordinate(aTag[2], aTag[1], aTag[3]);
925
- return fromBech32((ENCODED.exec(text2)?.[0] ?? text2).toLowerCase()) ?? invalid();
925
+ return fromBech32((ENCODED.exec(text3)?.[0] ?? text3).toLowerCase()) ?? invalid();
926
926
  }
927
927
 
928
928
  // src/applets/resolve.ts
@@ -1100,10 +1100,10 @@ import {
1100
1100
  resolveShellEnvironment
1101
1101
  } from "@kehto/shell";
1102
1102
  import { createAppletCsp, renderInsertionLockScript } from "@kernlize/guard";
1103
- function spliceOnce(text2, find, replacement) {
1104
- const at = text2.indexOf(find);
1103
+ function spliceOnce(text3, find, replacement) {
1104
+ const at = text3.indexOf(find);
1105
1105
  if (at === -1) throw new Error("unavailable:frame-lock");
1106
- return `${text2.slice(0, at)}${replacement}${text2.slice(at + find.length)}`;
1106
+ return `${text3.slice(0, at)}${replacement}${text3.slice(at + find.length)}`;
1107
1107
  }
1108
1108
  var NESTED_CONTEXT_LOCK = Object.freeze({ nestedContextLock: true });
1109
1109
  function assertNoFrame(html) {
@@ -1204,10 +1204,10 @@ import {
1204
1204
  estimateEnvelopeSize
1205
1205
  } from "@kernlize/guard";
1206
1206
  function toEnvelope(data) {
1207
- const record = typeof data === "object" && data !== null ? data : {};
1208
- 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 : {};
1209
1209
  const envelope = {
1210
- type: typeof record.type === "string" ? record.type : "unknown",
1210
+ type: typeof record2.type === "string" ? record2.type : "unknown",
1211
1211
  size: estimateEnvelopeSize(data)
1212
1212
  };
1213
1213
  return typeof event.kind === "number" ? { ...envelope, kind: event.kind } : envelope;
@@ -1424,7 +1424,9 @@ var DOMAIN_CAPABILITIES = Object.freeze({
1424
1424
  dm: ["dm:read", "dm:write"],
1425
1425
  fs: ["fs:read", "fs:write"],
1426
1426
  llm: ["llm:generate"],
1427
- 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: []
1428
1430
  });
1429
1431
  var BASELINE_DOMAINS = Object.freeze(["shell", "inc", "theme", "storage"]);
1430
1432
  function capabilitiesForDomain(domain) {
@@ -1453,7 +1455,7 @@ function createGrants(options) {
1453
1455
  function stored(identity) {
1454
1456
  return records.get(keyOf(identity)) ?? { dTag: identity.dTag, hash: identity.hash, domains: [], blocked: false };
1455
1457
  }
1456
- function record(entry) {
1458
+ function record2(entry) {
1457
1459
  return {
1458
1460
  identity: { dTag: entry.dTag, hash: entry.hash },
1459
1461
  domains: Object.freeze([...entry.domains]),
@@ -1475,7 +1477,7 @@ function createGrants(options) {
1475
1477
  records.set(`${entry.dTag}:${entry.hash}`, entry);
1476
1478
  persist();
1477
1479
  syncAcl(entry);
1478
- const result = record(entry);
1480
+ const result = record2(entry);
1479
1481
  changes$.next(result);
1480
1482
  return result;
1481
1483
  }
@@ -1483,10 +1485,10 @@ function createGrants(options) {
1483
1485
  commit({ ...stored(identity), domains: [...domains] });
1484
1486
  }
1485
1487
  return {
1486
- list: () => [...records.values()].map(record),
1488
+ list: () => [...records.values()].map(record2),
1487
1489
  get: (identity) => {
1488
1490
  const entry = records.get(keyOf(identity));
1489
- return entry ? record(entry) : void 0;
1491
+ return entry ? record2(entry) : void 0;
1490
1492
  },
1491
1493
  ensure: (identity) => commit(stored(identity)),
1492
1494
  allowDomain(identity, domain) {
@@ -1512,8 +1514,8 @@ function createGrants(options) {
1512
1514
  }
1513
1515
  function createEnvironmentResolver(grants) {
1514
1516
  return (identity, available) => {
1515
- const record = grants.get({ dTag: identity.dTag, hash: identity.aggregateHash });
1516
- const allowed = new Set(record?.blocked ? ["shell"] : [...grants.baselineDomains(), ...record?.domains ?? []]);
1517
+ const record2 = grants.get({ dTag: identity.dTag, hash: identity.aggregateHash });
1518
+ const allowed = new Set(record2?.blocked ? ["shell"] : [...grants.baselineDomains(), ...record2?.domains ?? []]);
1517
1519
  return Object.freeze({
1518
1520
  domains: Object.freeze(available.domains.filter((domain) => allowed.has(domain))),
1519
1521
  services: Object.freeze(available.services.filter((service) => allowed.has(service)))
@@ -1919,14 +1921,14 @@ function createConversationStore() {
1919
1921
  const thread = threads.get(conversationId);
1920
1922
  thread?.messages.splice(thread.messages.findIndex((entry) => entry.id === id), 1);
1921
1923
  },
1922
- conversations(query = {}) {
1924
+ conversations(query2 = {}) {
1923
1925
  const all = [...threads].filter(([, thread]) => thread.messages.length > 0).sort(([, a], [, b]) => latest(b) - latest(a)).map(([id, thread]) => summarize2(id, thread));
1924
- const result = page(all, query.cursor, query.limit ?? DEFAULT_CONVERSATION_LIMIT);
1926
+ const result = page(all, query2.cursor, query2.limit ?? DEFAULT_CONVERSATION_LIMIT);
1925
1927
  return { conversations: result.items, ...result.cursor === void 0 ? {} : { cursor: result.cursor } };
1926
1928
  },
1927
- messages(query) {
1928
- const all = threads.get(query.conversationId)?.messages ?? [];
1929
- 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);
1930
1932
  return { messages: result.items, ...result.cursor === void 0 ? {} : { cursor: result.cursor } };
1931
1933
  }
1932
1934
  };
@@ -2041,13 +2043,13 @@ function createSignerBackend(options, format) {
2041
2043
  capabilities: CAPABILITIES
2042
2044
  };
2043
2045
  },
2044
- async conversations(query) {
2046
+ async conversations(query2) {
2045
2047
  await sync();
2046
- return store.conversations(query);
2048
+ return store.conversations(query2);
2047
2049
  },
2048
- async messages(query) {
2050
+ async messages(query2) {
2049
2051
  await sync();
2050
- return store.messages(query);
2052
+ return store.messages(query2);
2051
2053
  },
2052
2054
  async send(request) {
2053
2055
  const current = session();
@@ -2156,9 +2158,9 @@ import { NdrRuntime } from "nostr-double-ratchet";
2156
2158
 
2157
2159
  // src/messaging/ratchet-storage.ts
2158
2160
  var CHUNK_UNITS = 16384;
2159
- function chunks(text2) {
2161
+ function chunks(text3) {
2160
2162
  const parts = [];
2161
- 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));
2162
2164
  return parts;
2163
2165
  }
2164
2166
  function createSealedRatchetStorage(options) {
@@ -2318,13 +2320,13 @@ function createRatchetMessagesBackend(options) {
2318
2320
  const self = options.selfPubkey();
2319
2321
  return { available: usable(), ...self === void 0 ? {} : { ownerPubkey: self }, implementations: ["ndr"], capabilities: CAPABILITIES2 };
2320
2322
  },
2321
- async conversations(query) {
2323
+ async conversations(query2) {
2322
2324
  await sync();
2323
- return store.conversations(query);
2325
+ return store.conversations(query2);
2324
2326
  },
2325
- async messages(query) {
2327
+ async messages(query2) {
2326
2328
  await sync();
2327
- return store.messages(query);
2329
+ return store.messages(query2);
2328
2330
  },
2329
2331
  async send(request) {
2330
2332
  const availability = signerAvailability(signerOf2(), "nip44");
@@ -2422,9 +2424,9 @@ function createSealedGroupStore(options, name) {
2422
2424
  const loading = open();
2423
2425
  let writes = loading;
2424
2426
  const seal = async (entries) => {
2425
- const text2 = JSON.stringify(Object.fromEntries(entries), encode);
2427
+ const text3 = JSON.stringify(Object.fromEntries(entries), encode);
2426
2428
  const parts = [];
2427
- 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));
2428
2430
  storage.setItem(key, JSON.stringify(await Promise.all(parts.map((part) => nip44.encrypt(owner, part)))));
2429
2431
  };
2430
2432
  const write = (change) => {
@@ -2625,13 +2627,13 @@ function createGroupMessagesBackend(options) {
2625
2627
  capabilities: CAPABILITIES3
2626
2628
  };
2627
2629
  },
2628
- async conversations(query) {
2630
+ async conversations(query2) {
2629
2631
  await sync();
2630
- return store.conversations(query);
2632
+ return store.conversations(query2);
2631
2633
  },
2632
- async messages(query) {
2634
+ async messages(query2) {
2633
2635
  await sync();
2634
- return store.messages(query);
2636
+ return store.messages(query2);
2635
2637
  },
2636
2638
  async send(request) {
2637
2639
  const live = active();
@@ -2701,8 +2703,8 @@ function labelConversations(adapter, profiles) {
2701
2703
  };
2702
2704
  return {
2703
2705
  ...adapter,
2704
- async conversations(query) {
2705
- const page2 = await adapter.conversations(query);
2706
+ async conversations(query2) {
2707
+ const page2 = await adapter.conversations(query2);
2706
2708
  return { ...page2, conversations: await Promise.all(page2.conversations.map(named)) };
2707
2709
  }
2708
2710
  };
@@ -2856,15 +2858,15 @@ function createBlossomUploader(options) {
2856
2858
  var STORAGE_KEY4 = "applet-config:v1";
2857
2859
  function createAppletConfig(options) {
2858
2860
  const store = createNamespacedStore(options.storage, "kernl");
2859
- const read = () => store.getJson(STORAGE_KEY4, {});
2861
+ const read2 = () => store.getJson(STORAGE_KEY4, {});
2860
2862
  return {
2861
2863
  getValues(windowId) {
2862
2864
  const applet = options.appletOf(windowId);
2863
- return applet ? { ...read()[applet.key] } : {};
2865
+ return applet ? { ...read2()[applet.key] } : {};
2864
2866
  },
2865
2867
  saveValues(windowId, values) {
2866
2868
  const applet = options.appletOf(windowId);
2867
- if (applet) store.setJson(STORAGE_KEY4, { ...read(), [applet.key]: values });
2869
+ if (applet) store.setJson(STORAGE_KEY4, { ...read2(), [applet.key]: values });
2868
2870
  },
2869
2871
  openSettings(windowId, section, context) {
2870
2872
  const applet = options.appletOf(windowId);
@@ -2937,9 +2939,9 @@ function createCommonActions(options) {
2937
2939
  const tags = [["e", targetEventId], ...target ? [["p", target.pubkey], ["k", String(target.kind)]] : [], ...emoji];
2938
2940
  return signed(options, context.windowId, { kind: REACTION, created_at: unixNow5(), tags, content: reaction });
2939
2941
  },
2940
- report(target, reason, text2, context) {
2942
+ report(target, reason, text3, context) {
2941
2943
  const tags = target.type === "event" ? [["e", target.id, reason], ...target.pubkey ? [["p", target.pubkey]] : []] : [["p", target.pubkey, reason]];
2942
- return signed(options, context.windowId, { kind: REPORT, created_at: unixNow5(), tags, content: text2 });
2944
+ return signed(options, context.windowId, { kind: REPORT, created_at: unixNow5(), tags, content: text3 });
2943
2945
  }
2944
2946
  };
2945
2947
  }
@@ -3073,8 +3075,643 @@ function commonActionsFor(parts, network, consent) {
3073
3075
  });
3074
3076
  }
3075
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
+ }
3712
+
3076
3713
  // src/kernl-services.ts
3077
- import { verifyEvent as verifyEvent4 } from "applesauce-core/helpers";
3714
+ import { verifyEvent as verifyEvent6 } from "applesauce-core/helpers";
3078
3715
  import {
3079
3716
  createCommonService,
3080
3717
  createConfigService,
@@ -3092,8 +3729,8 @@ import { createBridgeResourceResolver } from "@kernlize/bridges";
3092
3729
  function isTheme(value) {
3093
3730
  const colors = value?.colors;
3094
3731
  if (typeof colors !== "object" || colors === null) return false;
3095
- const { background, text: text2, primary } = colors;
3096
- return typeof background === "string" && typeof text2 === "string" && typeof primary === "string";
3732
+ const { background, text: text3, primary } = colors;
3733
+ return typeof background === "string" && typeof text3 === "string" && typeof primary === "string";
3097
3734
  }
3098
3735
  var LINK_PROTOCOLS = Object.freeze(["https:", "mailto:"]);
3099
3736
  function toRelayListEntry(relays2) {
@@ -3154,7 +3791,7 @@ function createOutbox(deps, identity) {
3154
3791
  if (!signer?.signEvent) throw new Error("denied:read-only");
3155
3792
  return signer.signEvent(template);
3156
3793
  },
3157
- verifyEvent: (event) => verifyEvent4(event)
3794
+ verifyEvent: (event) => verifyEvent6(event)
3158
3795
  });
3159
3796
  return createOutboxService({ router: acceptAnyRelay(router) });
3160
3797
  }
@@ -3183,6 +3820,9 @@ function createKernlServices(deps) {
3183
3820
  const composite = deps.messaging.composite();
3184
3821
  const dm = createDmService({ adapter: deps.profiles ? labelConversations(composite, deps.profiles) : composite });
3185
3822
  const resolve = createBridgeResourceResolver(deps.bridges);
3823
+ const identities = deps.identities ?? createWindowIdentities();
3824
+ const direct = deps.directConnections;
3825
+ const chosen = () => deps.multiplayer?.state();
3186
3826
  const registry = {
3187
3827
  relay: createAppletRelayService(deps.pool, deps.tiers),
3188
3828
  identity: createIdentityService({ getSigner: createIdentitySigner(deps.auth), ...identity }),
@@ -3202,6 +3842,21 @@ function createKernlServices(deps) {
3202
3842
  }),
3203
3843
  dm,
3204
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
+ } : {},
3205
3860
  ...deps.config ? { config: createConfigService(deps.config).handler } : {},
3206
3861
  ...deps.common ? { common: createCommonService(deps.common) } : {},
3207
3862
  ...deps.uploader ? { upload: createUploadService({ uploader: deps.uploader, uploadInfo: { rails: [{ rail: "blossom", enabled: true }] } }) } : {}
@@ -3210,7 +3865,7 @@ function createKernlServices(deps) {
3210
3865
  }
3211
3866
 
3212
3867
  // src/kernl-adapter.ts
3213
- import { verifyEvent as verifyEvent5 } from "applesauce-core/helpers";
3868
+ import { verifyEvent as verifyEvent7 } from "applesauce-core/helpers";
3214
3869
  var TIERS2 = ["discovery", "apps", "outbox", "super"];
3215
3870
  var UPLOAD_BACKEND = Object.freeze({ rails: Object.freeze(["blossom"]) });
3216
3871
  function isTier(tier) {
@@ -3241,7 +3896,9 @@ function createShellAdapter(deps) {
3241
3896
  // kehto offers the upload domain only when both the service and this backend are present; kernl's uploads are Blossom (D-033).
3242
3897
  upload: { getUploader: () => deps.services.upload ? UPLOAD_BACKEND : null },
3243
3898
  common: { isAvailable: () => deps.services.common !== void 0 },
3244
- crypto: { verifyEvent: (event) => Promise.resolve(verifyEvent5(event)) },
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)) },
3245
3902
  link: { isAvailable: () => true },
3246
3903
  intent: { isAvailable: () => true },
3247
3904
  services: deps.services,
@@ -3257,11 +3914,11 @@ function createShellAdapter(deps) {
3257
3914
 
3258
3915
  // src/kernl-lifecycle.ts
3259
3916
  import { originRegistry } from "@kehto/shell";
3260
- function grantNarrowingReason(plan, record, baseline) {
3917
+ function grantNarrowingReason(plan, record2, baseline) {
3261
3918
  const { identity } = plan.summary;
3262
- if (record.identity.dTag !== identity.dTag || record.identity.hash !== identity.hash) return void 0;
3263
- if (record.blocked) return "blocked";
3264
- const allowed = /* @__PURE__ */ new Set([...baseline, ...record.domains]);
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]);
3265
3922
  return plan.environment.capabilities.domains.some((domain) => !allowed.has(domain)) ? "grant-narrowed" : void 0;
3266
3923
  }
3267
3924
  function keyOf2(identity) {
@@ -3322,8 +3979,8 @@ function createAppletLifecycle(context) {
3322
3979
  onRevoked: (windowId, reason) => context.host.onRevoked(windowId, reason)
3323
3980
  });
3324
3981
  handles.set(plan.windowId, handle);
3325
- const narrowed = context.grants.changes$.subscribe((record) => {
3326
- const reason = grantNarrowingReason(plan, record, context.grants.baselineDomains());
3982
+ const narrowed = context.grants.changes$.subscribe((record2) => {
3983
+ const reason = grantNarrowingReason(plan, record2, context.grants.baselineDomains());
3327
3984
  if (!reason) return;
3328
3985
  handle.revoked(reason);
3329
3986
  bridge.revokeNapplet(plan.windowId, "host");
@@ -3344,7 +4001,7 @@ function createAppletLifecycle(context) {
3344
4001
  }
3345
4002
 
3346
4003
  // src/kernl.ts
3347
- import { BehaviorSubject as BehaviorSubject8, map as map9, of as of3, Subject as Subject4, Subscription as Subscription2, switchMap as switchMap5 } from "rxjs";
4004
+ import { BehaviorSubject as BehaviorSubject9, map as map9, of as of3, Subject as Subject4, Subscription as Subscription2, switchMap as switchMap5 } from "rxjs";
3348
4005
  import { EventStore } from "applesauce-core";
3349
4006
  import { RelayPool } from "applesauce-relay";
3350
4007
  import { buildShellCapabilities, createShellBridge } from "@kehto/shell";
@@ -3355,8 +4012,8 @@ import { Subscription } from "rxjs";
3355
4012
  import { createIntentService } from "@kehto/services";
3356
4013
 
3357
4014
  // src/intents/defaults.ts
3358
- import { lastValueFrom as lastValueFrom8, Subject as Subject3, takeUntil as takeUntil3, timer as timer5, toArray as toArray5 } from "rxjs";
3359
- import { verifyEvent as verifyEvent6 } from "applesauce-core/helpers";
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";
3360
4017
 
3361
4018
  // src/intents/preferences.ts
3362
4019
  var HANDLER_PREFERENCES_KIND = 31129;
@@ -3428,7 +4085,7 @@ function preferenceRelays(tiers) {
3428
4085
  function newestPerArchetype(events, pubkey) {
3429
4086
  const newest2 = /* @__PURE__ */ new Map();
3430
4087
  for (const event of events) {
3431
- 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;
3432
4089
  const archetype = event.tags.find((tag) => tag[0] === "d")?.[1] ?? "";
3433
4090
  const current = newest2.get(archetype);
3434
4091
  if (archetype && (!current || event.created_at > current.created_at)) newest2.set(archetype, event);
@@ -3471,7 +4128,7 @@ function createHandlerDefaults(options) {
3471
4128
  loadedFor = pubkey;
3472
4129
  if (!pubkey) return;
3473
4130
  const request = options.pool.request([...preferenceRelays(options.tiers)], asFilters([{ kinds: [HANDLER_PREFERENCES_KIND], authors: [pubkey] }]));
3474
- const events = await lastValueFrom8(request.pipe(takeUntil3(timer5(LOAD_TIMEOUT_MS)), toArray5()), { defaultValue: [] }).catch(() => []);
4131
+ const events = await lastValueFrom9(request.pipe(takeUntil4(timer6(LOAD_TIMEOUT_MS)), toArray6()), { defaultValue: [] }).catch(() => []);
3475
4132
  for (const [archetype, event] of newestPerArchetype(events, pubkey)) {
3476
4133
  published.set(archetype, event);
3477
4134
  changes$.next(archetype);
@@ -3516,9 +4173,9 @@ function createIntentDelivery(options) {
3516
4173
  }
3517
4174
 
3518
4175
  // src/intents/installed.ts
3519
- import { BehaviorSubject as BehaviorSubject7 } from "rxjs";
4176
+ import { BehaviorSubject as BehaviorSubject8 } from "rxjs";
3520
4177
  import { manifestToIntentCatalogEntry } from "@kehto/services";
3521
- var STORAGE_KEY5 = "installed:v1";
4178
+ var STORAGE_KEY6 = "installed:v1";
3522
4179
  function isInstalled(value) {
3523
4180
  if (typeof value !== "object" || value === null) return false;
3524
4181
  const row = value;
@@ -3538,10 +4195,10 @@ function toCatalogEntry2(applet) {
3538
4195
  }
3539
4196
  function createInstalledApplets(storage, now = Date.now) {
3540
4197
  const store = createNamespacedStore(storage, "kernl");
3541
- const stored = store.getJson(STORAGE_KEY5, []);
3542
- const changes$ = new BehaviorSubject7(Object.freeze(Array.isArray(stored) ? stored.filter(isInstalled) : []));
4198
+ const stored = store.getJson(STORAGE_KEY6, []);
4199
+ const changes$ = new BehaviorSubject8(Object.freeze(Array.isArray(stored) ? stored.filter(isInstalled) : []));
3543
4200
  const commit = (next) => {
3544
- store.setJson(STORAGE_KEY5, next);
4201
+ store.setJson(STORAGE_KEY6, next);
3545
4202
  changes$.next(Object.freeze([...next]));
3546
4203
  };
3547
4204
  return {
@@ -3733,7 +4390,7 @@ function createKernlIntents(deps) {
3733
4390
  }
3734
4391
 
3735
4392
  // src/catalog/fetch.ts
3736
- import { auditTime as auditTime2, catchError as catchError4, EMPTY as EMPTY4, from, lastValueFrom as lastValueFrom9, map as map8, merge as merge4, mergeAll, scan, share as share2, takeUntil as takeUntil4, tap, timer as timer6 } from "rxjs";
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";
3737
4394
  import { getSeenRelays } from "applesauce-core/helpers";
3738
4395
  import { NAPPLET_KIND_NAMED, NAPPLET_KIND_ROOT } from "@kehto/nip/5d";
3739
4396
 
@@ -3783,7 +4440,7 @@ function streamCatalog(pool, tiers, options = {}) {
3783
4440
  const filters = asFilters(catalogFilters(options));
3784
4441
  const cached = options.cache ? from(options.cache(filters).catch(() => [])).pipe(mergeAll()) : EMPTY4;
3785
4442
  const live = pool.request([...relays2], filters).pipe(
3786
- takeUntil4(timer6(options.timeoutMs ?? CATALOG_TIMEOUT_MS)),
4443
+ takeUntil5(timer7(options.timeoutMs ?? CATALOG_TIMEOUT_MS)),
3787
4444
  catchError4(() => EMPTY4),
3788
4445
  tap((event) => options.store?.add(event))
3789
4446
  );
@@ -3797,11 +4454,11 @@ function streamCatalog(pool, tiers, options = {}) {
3797
4454
  );
3798
4455
  const listed = (state) => newestEntries(state.listed.filter(({ event }) => !isWithdrawn(event, state.withdrawn)).map(({ entry }) => entry));
3799
4456
  const lists = found.pipe(auditTime2(options.emitMs ?? CATALOG_EMIT_MS), map8(listed), share2());
3800
- const nothingYet = timer6(options.settleMs ?? CATALOG_SETTLE_MS).pipe(map8(() => Object.freeze([])), takeUntil4(lists));
4457
+ const nothingYet = timer7(options.settleMs ?? CATALOG_SETTLE_MS).pipe(map8(() => Object.freeze([])), takeUntil5(lists));
3801
4458
  return merge4(nothingYet, lists);
3802
4459
  }
3803
4460
  async function loadCatalog(pool, tiers, options = {}) {
3804
- return lastValueFrom9(streamCatalog(pool, tiers, options), { defaultValue: Object.freeze([]) });
4461
+ return lastValueFrom10(streamCatalog(pool, tiers, options), { defaultValue: Object.freeze([]) });
3805
4462
  }
3806
4463
 
3807
4464
  // src/kernl.ts
@@ -3881,6 +4538,37 @@ function registriesFor(options, parts) {
3881
4538
  bridges: options.bridges ?? createDefaultBridges({ handoff: (uri) => host.openLink(uri), ...options.torrent ? { torrent: options.torrent } : {} })
3882
4539
  };
3883
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
+ }
3884
4572
  function appletOf(handles, windowId) {
3885
4573
  const summary = handles.get(windowId)?.summary;
3886
4574
  return summary && { key: summary.manifest.catalogId, title: summary.title };
@@ -3908,7 +4596,7 @@ function createKernl(options) {
3908
4596
  const { messaging, bridges } = registriesFor(options, { eventStore, pool, tiers, accounts });
3909
4597
  const handles = /* @__PURE__ */ new Map();
3910
4598
  const guardEvents$ = new Subject4();
3911
- const session$ = new BehaviorSubject8(null);
4599
+ const session$ = new BehaviorSubject9(null);
3912
4600
  const destroyed$ = new Subject4();
3913
4601
  const subscriptions = new Subscription2();
3914
4602
  let grants;
@@ -3930,6 +4618,7 @@ function createKernl(options) {
3930
4618
  relays: () => [...tiers.get().outbox, ...tiers.get().discovery]
3931
4619
  });
3932
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 });
3933
4622
  const services = createKernlServices({
3934
4623
  pool,
3935
4624
  tiers,
@@ -3942,12 +4631,9 @@ function createKernl(options) {
3942
4631
  profiles,
3943
4632
  ...host.presentSettings ? { config: createAppletConfig({ storage: host.storage, appletOf: (windowId) => appletOf(handles, windowId), present: host.presentSettings.bind(host) }) } : {},
3944
4633
  common: commonActionsFor({ eventStore, pool, tiers, accounts }, { profiles, replaceableLoader, signer }, consent),
3945
- uploader: createBlossomUploader({
3946
- servers: () => files.current(),
3947
- signer,
3948
- ask: (windowId, details) => askUploadConsent(host, identityOf(windowId), details)
3949
- }),
4634
+ uploader: uploaderFor(host, files, signer, identityOf),
3950
4635
  ...isTheme(options.theme) ? { theme: options.theme } : {},
4636
+ ...meeting.deps,
3951
4637
  resolveIdentity(windowId) {
3952
4638
  const identity = identityOf(windowId);
3953
4639
  return identity ? { dTag: identity.dTag, aggregateHash: identity.hash } : null;
@@ -4009,6 +4695,7 @@ function createKernl(options) {
4009
4695
  profiles,
4010
4696
  mailboxes,
4011
4697
  files,
4698
+ multiplayer: meeting.multiplayer,
4012
4699
  directory,
4013
4700
  intents: intents.intents,
4014
4701
  session$,
@@ -4051,8 +4738,8 @@ function wordScore(word, entry) {
4051
4738
  }
4052
4739
  return best;
4053
4740
  }
4054
- function textScore(text2, entry) {
4055
- const words = text2.toLowerCase().split(/\s+/).filter(Boolean);
4741
+ function textScore(text3, entry) {
4742
+ const words = text3.toLowerCase().split(/\s+/).filter(Boolean);
4056
4743
  let total = 0;
4057
4744
  for (const word of words) {
4058
4745
  const score = wordScore(word, entry);
@@ -4061,16 +4748,16 @@ function textScore(text2, entry) {
4061
4748
  }
4062
4749
  return words.length === 0 ? 1 : total;
4063
4750
  }
4064
- function passesFilters(entry, query) {
4065
- if (query.topics?.some((topic) => !entry.topics.includes(topic))) return false;
4066
- if (query.available && entry.requires.some((domain) => !query.available?.includes(domain))) return false;
4067
- return query.convention === void 0 || entry.conventions.includes(query.convention);
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);
4068
4755
  }
4069
- function searchCatalog(entries, query = {}) {
4756
+ function searchCatalog(entries, query2 = {}) {
4070
4757
  const scored = [];
4071
4758
  for (const entry of entries) {
4072
- if (!passesFilters(entry, query)) continue;
4073
- const score = textScore(query.text ?? "", entry);
4759
+ if (!passesFilters(entry, query2)) continue;
4760
+ const score = textScore(query2.text ?? "", entry);
4074
4761
  if (score > 0) scored.push({ entry, score });
4075
4762
  }
4076
4763
  scored.sort((a, b) => b.score - a.score || b.entry.publishedAt - a.entry.publishedAt);
@@ -4102,6 +4789,9 @@ export {
4102
4789
  DEFAULT_RELAY_TIERS,
4103
4790
  DEFAULT_SUGGESTIONS,
4104
4791
  DELIVERY_RETRY,
4792
+ DIRECT_MAX_PAYLOAD_BYTES,
4793
+ DIRECT_SIGNALING_PROFILE,
4794
+ DIRECT_SIGNAL_KIND,
4105
4795
  DOMAIN_CAPABILITIES,
4106
4796
  HANDLER_PREFERENCES_KIND,
4107
4797
  KERNL_FRAME_POLICY_META,
@@ -4114,6 +4804,7 @@ export {
4114
4804
  RUNTIME_FIREWALL_STORAGE_KEY,
4115
4805
  RUNTIME_OP_CLASSES,
4116
4806
  SHELL_RELAY_OPTIONS,
4807
+ TOOL_DISCOVERY_TIMEOUT_MS,
4117
4808
  UNKNOWN_CURRENT_VERSION,
4118
4809
  abbreviate,
4119
4810
  addressOf,
@@ -4139,9 +4830,12 @@ export {
4139
4830
  createColumnsLayout,
4140
4831
  createCommonActions,
4141
4832
  createConsentHandler,
4833
+ createCvmRelayPool,
4142
4834
  createDefaultBridges,
4143
4835
  createDefaultLayouts,
4144
4836
  createDefaultMessaging,
4837
+ createDirectConnectionsService,
4838
+ createDirectSignaling,
4145
4839
  createDmRelayPool,
4146
4840
  createDwindleLayout,
4147
4841
  createEnvironmentResolver,
@@ -4166,6 +4860,7 @@ export {
4166
4860
  createLegacyMessagesBackend,
4167
4861
  createMasterStackLayout,
4168
4862
  createMemoryCacheAdapter,
4863
+ createMultiplayerSettings,
4169
4864
  createNamespacedStore,
4170
4865
  createOutboxRelayPool,
4171
4866
  createPrivateMessagesBackend,
@@ -4175,6 +4870,7 @@ export {
4175
4870
  createRelayPoolHooks,
4176
4871
  createRelayPoolLike,
4177
4872
  createRelayTiers,
4873
+ createRemoteToolsService,
4178
4874
  createReplaceableLoader,
4179
4875
  createRuntimeFirewallHooks,
4180
4876
  createSealedGroupStore,
@@ -4182,13 +4878,17 @@ export {
4182
4878
  createShellAdapter,
4183
4879
  createSigningConsent,
4184
4880
  createSqliteOpfsCacheAdapter,
4881
+ createWindowIdentities,
4185
4882
  createWindowManager,
4186
4883
  decodePointer,
4187
4884
  defaultFetchBlob,
4188
4885
  defaultWebCacheAdapters,
4189
4886
  describeChange,
4887
+ describeDirectConnection,
4190
4888
  describeOutcome,
4191
4889
  describeUpload,
4890
+ directNamespace,
4891
+ discoverToolFamilies,
4192
4892
  fetchManifestEvent,
4193
4893
  fileServerTags,
4194
4894
  fileServersFromEvent,
@@ -4207,6 +4907,7 @@ export {
4207
4907
  lookupReplaceable,
4208
4908
  mailboxTags,
4209
4909
  mailboxesFromEvent,
4910
+ mergeFamilies,
4210
4911
  messagingSigner,
4211
4912
  mountApplet,
4212
4913
  newestEntries,
@@ -4241,6 +4942,7 @@ export {
4241
4942
  toProfileCard,
4242
4943
  toRelayUrl,
4243
4944
  toSession,
4945
+ validFamily,
4244
4946
  wrapAccountSigner
4245
4947
  };
4246
4948
  //# sourceMappingURL=index.js.map