@kehto/shell 0.16.4 → 0.16.6

package/dist/index.js

@@ -1025,7 +1025,6 @@ function buildShellCapabilities(hooks) {
   if (hooks.webrtc?.isAvailable()) domains.push("webrtc");
   if (hooks.dm) domains.push("dm");
   const sandbox = [];
-  domains.push(...sandbox);
   const protocols = {};
   for (const entry of NAP_INC_PROTOCOLS) {
     const [domain, protocol] = entry.split(":");
@@ -1275,18 +1274,777 @@ function injectNappletNamespacePrelude(html, options) {
 }
 function nappletNamespacePrelude(domains) {
   const target = window;
+  const allowed = new Set(domains);
+  const requestTimeoutMs = 3e4;
+  function id() {
+    if (target.crypto?.randomUUID) return target.crypto.randomUUID();
+    return `napplet-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  }
+  function post(message) {
+    target.parent.postMessage(message, "*");
+  }
+  function listen(listener) {
+    target.addEventListener("message", listener);
+    return () => target.removeEventListener("message", listener);
+  }
+  function isParentMessage(event) {
+    return event.source === target.parent;
+  }
+  function request(message, resultType, map, options = {}) {
+    const requestId = message.id ?? id();
+    const outbound = { ...message, id: requestId };
+    return new Promise((resolve, reject) => {
+      const off = listen((event) => {
+        if (!isParentMessage(event)) return;
+        const incoming = event.data;
+        if (typeof incoming !== "object" || incoming === null) return;
+        const msg = incoming;
+        if (msg.type !== resultType && msg.type !== `${message.type}.error`) return;
+        if (msg.id !== requestId) return;
+        off();
+        clearTimeout(timer);
+        const error = typeof msg.error === "string" ? msg.error : "";
+        if (error && options.rejectOnError !== false) {
+          reject(new Error(error));
+          return;
+        }
+        try {
+          resolve(map(msg));
+        } catch (err) {
+          reject(err);
+        }
+      });
+      const timer = setTimeout(() => {
+        off();
+        reject(new Error(`${message.type} timed out`));
+      }, requestTimeoutMs);
+      post(outbound);
+    });
+  }
+  function fire(message) {
+    post(message);
+  }
+  function resultOrError(msg) {
+    return msg;
+  }
+  function withoutEnvelope(msg) {
+    const { type: _type, id: _id, ...result } = msg;
+    return result;
+  }
+  function fieldOrThrow(msg, field, fallback) {
+    if (Object.prototype.hasOwnProperty.call(msg, field)) return msg[field];
+    throw new Error(typeof msg.error === "string" ? msg.error : fallback);
+  }
+  function voidResult(msg, fallback) {
+    if (typeof msg.error === "string" && msg.error) throw new Error(msg.error);
+    if (msg.ok === false) throw new Error(fallback);
+  }
+  function subscriptionHandle(close) {
+    let closed = false;
+    return {
+      close() {
+        if (closed) return;
+        closed = true;
+        close();
+      }
+    };
+  }
+  function domainEventHandle(eventType, callback, select = (message) => message.event) {
+    const off = listen((event) => {
+      if (!isParentMessage(event)) return;
+      const msg = event.data;
+      if (typeof msg === "object" && msg !== null && msg.type === eventType) callback(select(msg));
+    });
+    return subscriptionHandle(off);
+  }
+  function makeRelay() {
+    return {
+      subscribe(filters, onEvent, onEose, options) {
+        const subId = id();
+        const off = listen((event) => {
+          if (!isParentMessage(event)) return;
+          const msg = event.data;
+          if (typeof msg !== "object" || msg === null || msg.subId !== subId) return;
+          if (msg.type === "relay.event") onEvent(msg.result);
+          else if (msg.type === "relay.eose") onEose();
+          else if (msg.type === "relay.closed") off();
+        });
+        fire({
+          type: "relay.subscribe",
+          id: id(),
+          subId,
+          filters: Array.isArray(filters) ? filters : [filters],
+          ...options?.relay ? { relay: options.relay } : {}
+        });
+        return subscriptionHandle(() => {
+          fire({ type: "relay.close", id: id(), subId });
+          off();
+        });
+      },
+      publish(template) {
+        return request(
+          { type: "relay.publish", event: template },
+          "relay.publish.result",
+          (msg) => {
+            if (!msg.event) throw new Error("relay.publish.result missing event");
+            return msg.event;
+          }
+        );
+      },
+      publishEncrypted(template, recipient, encryption = "nip44") {
+        return request(
+          { type: "relay.publishEncrypted", event: template, recipient, encryption },
+          "relay.publishEncrypted.result",
+          (msg) => {
+            if (!msg.event) throw new Error("relay.publishEncrypted.result missing event");
+            return msg.event;
+          }
+        );
+      },
+      query(filters) {
+        return request(
+          { type: "relay.query", filters: Array.isArray(filters) ? filters : [filters] },
+          "relay.query.result",
+          (msg) => Array.isArray(msg.events) ? msg.events : []
+        );
+      }
+    };
+  }
+  function makeInc() {
+    return {
+      emit(topic, _extraTags, content) {
+        let payload = content;
+        if (typeof content === "string" && content.length > 0) {
+          try {
+            payload = JSON.parse(content);
+          } catch {
+            payload = content;
+          }
+        }
+        fire({ type: "inc.emit", topic, ...payload === void 0 || payload === "" ? {} : { payload } });
+      },
+      on(topic, callback) {
+        const off = listen((event) => {
+          if (!isParentMessage(event)) return;
+          const msg = event.data;
+          if (typeof msg !== "object" || msg === null || msg.type !== "inc.event" || msg.topic !== topic) return;
+          callback(msg.payload ?? {}, {
+            id: "",
+            pubkey: typeof msg.sender === "string" ? msg.sender : "",
+            created_at: Math.floor(Date.now() / 1e3),
+            kind: 0,
+            tags: [["t", topic]],
+            content: typeof msg.payload === "string" ? msg.payload : JSON.stringify(msg.payload ?? {}),
+            sig: ""
+          });
+        });
+        fire({ type: "inc.subscribe", id: id(), topic });
+        return subscriptionHandle(() => {
+          fire({ type: "inc.unsubscribe", topic });
+          off();
+        });
+      }
+    };
+  }
+  function makeStorage() {
+    const makeScope = (scope) => ({
+      getItem(key) {
+        return request(
+          { type: "storage.get", key, ...scope ? { scope } : {} },
+          "storage.get.result",
+          (msg) => msg.value ?? null
+        );
+      },
+      setItem(key, value) {
+        return request(
+          { type: "storage.set", key, value, ...scope ? { scope } : {} },
+          "storage.set.result",
+          () => void 0
+        );
+      },
+      removeItem(key) {
+        return request(
+          { type: "storage.remove", key, ...scope ? { scope } : {} },
+          "storage.remove.result",
+          () => void 0
+        );
+      },
+      keys() {
+        return request(
+          { type: "storage.keys", ...scope ? { scope } : {} },
+          "storage.keys.result",
+          (msg) => Array.isArray(msg.keys) ? msg.keys : []
+        );
+      }
+    });
+    return { ...makeScope(), instance: makeScope("instance") };
+  }
+  function makeIdentity() {
+    const read = (type, field, fallback) => request(
+      { type },
+      `${type}.result`,
+      (msg) => Object.prototype.hasOwnProperty.call(msg, field) ? msg[field] : fallback,
+      { rejectOnError: type !== "identity.getPublicKey" }
+    );
+    return {
+      getPublicKey: () => read("identity.getPublicKey", "pubkey", ""),
+      onChanged(handler) {
+        const off = listen((event) => {
+          if (!isParentMessage(event)) return;
+          const msg = event.data;
+          if (typeof msg !== "object" || msg === null || msg.type !== "identity.changed") return;
+          if (typeof msg.pubkey === "string") handler(msg.pubkey);
+        });
+        return subscriptionHandle(off);
+      },
+      getRelays: () => read("identity.getRelays", "relays", {}),
+      getProfile: () => read("identity.getProfile", "profile", null),
+      getFollows: () => read("identity.getFollows", "pubkeys", []),
+      getList: (listType) => request(
+        { type: "identity.getList", listType },
+        "identity.getList.result",
+        (msg) => Array.isArray(msg.entries) ? msg.entries : []
+      ),
+      getZaps: () => read("identity.getZaps", "zaps", []),
+      getMutes: () => read("identity.getMutes", "pubkeys", []),
+      getBlocked: () => read("identity.getBlocked", "pubkeys", []),
+      getBadges: () => read("identity.getBadges", "badges", [])
+    };
+  }
+  function makeTheme() {
+    return {
+      get: () => request({ type: "theme.get" }, "theme.get.result", (msg) => msg.theme),
+      onChanged(handler) {
+        const off = listen((event) => {
+          if (!isParentMessage(event)) return;
+          const msg = event.data;
+          if (typeof msg === "object" && msg !== null && msg.type === "theme.changed") handler(msg.theme);
+        });
+        return subscriptionHandle(off);
+      }
+    };
+  }
+  function makeKeys() {
+    return {
+      forward: (event = {}) => fire({
+        type: "keys.forward",
+        key: typeof event.key === "string" ? event.key : "",
+        code: typeof event.code === "string" ? event.code : "",
+        ctrl: Boolean(event.ctrl ?? event.ctrlKey),
+        alt: Boolean(event.alt ?? event.altKey),
+        shift: Boolean(event.shift ?? event.shiftKey),
+        meta: Boolean(event.meta ?? event.metaKey)
+      }),
+      registerAction: (action) => request(
+        { type: "keys.registerAction", action },
+        "keys.registerAction.result",
+        resultOrError
+      ),
+      unregisterAction: (actionId) => fire({ type: "keys.unregisterAction", actionId }),
+      onAction(actionId, callback) {
+        const off = listen((event) => {
+          if (!isParentMessage(event)) return;
+          const msg = event.data;
+          if (typeof msg === "object" && msg !== null && msg.type === "keys.action" && msg.actionId === actionId) callback();
+        });
+        return subscriptionHandle(off);
+      }
+    };
+  }
+  function makeMedia() {
+    const on = (type, sessionId, callback) => {
+      const off = listen((event) => {
+        if (!isParentMessage(event)) return;
+        const msg = event.data;
+        if (typeof msg === "object" && msg !== null && msg.type === type && msg.sessionId === sessionId) callback(msg);
+      });
+      return subscriptionHandle(off);
+    };
+    return {
+      createSession: (options) => request(
+        { type: "media.session.create", ...options && typeof options === "object" ? options : {} },
+        "media.session.create.result",
+        withoutEnvelope,
+        { rejectOnError: false }
+      ),
+      updateSession: (sessionId, metadata) => fire({ type: "media.session.update", sessionId, metadata }),
+      destroySession: (sessionId) => fire({ type: "media.session.destroy", sessionId }),
+      reportState: (sessionId, state) => fire({ type: "media.state", sessionId, ...state && typeof state === "object" ? state : {} }),
+      reportCapabilities: (sessionId, actions) => fire({ type: "media.capabilities", sessionId, actions }),
+      sendCommand: (sessionId, action, value) => fire({ type: "media.command", sessionId, action, ...value === void 0 ? {} : { value } }),
+      onCommand: (sessionId, callback) => on("media.command", sessionId, (msg) => callback(msg.action, msg.value)),
+      onState: (sessionId, callback) => on("media.state", sessionId, (msg) => callback({
+        status: msg.status,
+        position: msg.position,
+        duration: msg.duration,
+        volume: msg.volume
+      })),
+      onCapabilities: (sessionId, callback) => on("media.capabilities", sessionId, (msg) => callback(msg.actions)),
+      onControls: (sessionId, callback) => on("media.controls", sessionId, (msg) => callback(msg.controls))
+    };
+  }
+  function makeNotify() {
+    const on = (type, callback) => {
+      const off = listen((event) => {
+        if (!isParentMessage(event)) return;
+        const msg = event.data;
+        if (typeof msg === "object" && msg !== null && msg.type === type) callback(msg);
+      });
+      return subscriptionHandle(off);
+    };
+    return {
+      send: (notification) => request(
+        { type: "notify.send", ...notification },
+        "notify.send.result",
+        (msg) => ({ notificationId: fieldOrThrow(msg, "notificationId", "notify.send.result missing notificationId") })
+      ),
+      dismiss: (notificationId) => fire({ type: "notify.dismiss", notificationId }),
+      badge: (count) => fire({ type: "notify.badge", count }),
+      registerChannel: (channel) => fire({ type: "notify.channel.register", ...channel }),
+      requestPermission: (channel) => request(
+        { type: "notify.permission.request", ...channel ? { channel } : {} },
+        "notify.permission.result",
+        (msg) => ({ granted: msg.granted })
+      ),
+      onAction: (callback) => on("notify.action", (msg) => callback(msg.notificationId, msg.actionId)),
+      onClicked: (callback) => on("notify.clicked", (msg) => callback(msg.notificationId)),
+      onDismissed: (callback) => on("notify.dismissed", (msg) => callback(msg.notificationId, msg.reason)),
+      onControls: (callback) => on("notify.controls", (msg) => callback(msg.controls))
+    };
+  }
+  function makeConfig() {
+    let schema = null;
+    return {
+      registerSchema: (nextSchema, version2) => request(
+        { type: "config.registerSchema", schema: nextSchema, ...version2 === void 0 ? {} : { version: version2 } },
+        "config.registerSchema.result",
+        (msg) => {
+          if (!msg.error) schema = nextSchema;
+          return void 0;
+        }
+      ),
+      get: () => request({ type: "config.get" }, "config.values", (msg) => msg.values ?? {}),
+      subscribe(callback) {
+        const off = listen((event) => {
+          if (!isParentMessage(event)) return;
+          const msg = event.data;
+          if (typeof msg === "object" && msg !== null && msg.type === "config.values") callback(msg.values ?? {});
+        });
+        fire({ type: "config.subscribe" });
+        return subscriptionHandle(() => {
+          fire({ type: "config.unsubscribe" });
+          off();
+        });
+      },
+      openSettings: (options) => fire({ type: "config.openSettings", ...options && typeof options === "object" ? options : {} }),
+      onSchemaError(callback) {
+        const off = listen((event) => {
+          if (!isParentMessage(event)) return;
+          const msg = event.data;
+          if (typeof msg === "object" && msg !== null && msg.type === "config.schemaError") callback(msg);
+        });
+        return off;
+      },
+      get schema() {
+        return schema;
+      }
+    };
+  }
+  function makeResource() {
+    const objectUrls = /* @__PURE__ */ new Set();
+    const bytes = (url) => request({ type: "resource.bytes", url }, "resource.bytes.result", (msg) => msg.blob);
+    return {
+      info: () => request({ type: "resource.info" }, "resource.info.result", (msg) => msg.info),
+      bytes,
+      bytesMany: (urls) => request({ type: "resource.bytesMany", urls }, "resource.bytesMany.result", (msg) => Array.isArray(msg.items) ? msg.items : []),
+      bytesAsObjectURL(url) {
+        let objectUrl = "";
+        const handle = {
+          get url() {
+            return objectUrl;
+          },
+          revoke() {
+            if (objectUrl) {
+              URL.revokeObjectURL(objectUrl);
+              objectUrls.delete(objectUrl);
+              objectUrl = "";
+            }
+          }
+        };
+        void bytes(url).then((blob) => {
+          objectUrl = URL.createObjectURL(blob);
+          objectUrls.add(objectUrl);
+        });
+        return handle;
+      },
+      hydrateResourceCache: () => void 0,
+      revokeAllObjectURLs() {
+        for (const url of objectUrls) URL.revokeObjectURL(url);
+        objectUrls.clear();
+      }
+    };
+  }
+  function makeCvm() {
+    const req = (type, payload, map) => request(
+      { type, ...payload },
+      `${type}.result`,
+      map
+    );
+    const cvmRequest = (server, message, options) => req(
+      "cvm.request",
+      { server, message, ...options === void 0 ? {} : { options } },
+      (msg) => fieldOrThrow(msg, "message", "cvm.request.result missing message")
+    );
+    const mcpCall = async (server, method, params, options) => {
+      const reply = await cvmRequest(server, {
+        jsonrpc: "2.0",
+        id: id(),
+        method,
+        ...params === void 0 ? {} : { params }
+      }, options);
+      if (reply.error !== void 0) {
+        const error = reply.error;
+        throw new Error(typeof error === "object" && error !== null && typeof error.message === "string" ? `${method}: ${error.message}` : `${method} failed`);
+      }
+      return reply.result;
+    };
+    return {
+      discover: (query) => req("cvm.discover", query === void 0 ? {} : { query }, (msg) => Array.isArray(msg.servers) ? msg.servers : []),
+      request: cvmRequest,
+      listTools: async (server, options) => {
+        const result = await mcpCall(server, "tools/list", void 0, options);
+        return result?.tools ?? [];
+      },
+      callTool: (server, name, args, options) => mcpCall(
+        server,
+        "tools/call",
+        { name, ...args === void 0 ? {} : { arguments: args } },
+        options
+      ),
+      listResources: async (server, options) => {
+        const result = await mcpCall(server, "resources/list", void 0, options);
+        return result?.resources ?? [];
+      },
+      readResource: async (server, uri, options) => {
+        const result = await mcpCall(server, "resources/read", { uri }, options);
+        const first = result?.contents?.[0];
+        if (!first) throw new Error(`resources/read returned no contents for ${uri}`);
+        return first;
+      },
+      close: (server) => req("cvm.close", { server }, (msg) => voidResult(msg, "cvm close failed")),
+      onEvent(callback) {
+        const off = listen((event) => {
+          if (!isParentMessage(event)) return;
+          const msg = event.data;
+          if (typeof msg === "object" && msg !== null && msg.type === "cvm.event" && msg.server !== void 0 && msg.message !== void 0) {
+            callback(msg.server, msg.message);
+          }
+        });
+        return subscriptionHandle(off);
+      }
+    };
+  }
+  function makeOutbox() {
+    const req = (type, payload, resultType = `${type}.result`) => request(
+      { type, ...payload },
+      resultType,
+      resultOrError,
+      { rejectOnError: false }
+    );
+    return {
+      getEvent: (eventId, options) => req("outbox.getEvent", { eventId, ...options ? { options } : {} }),
+      query: (filters, options) => req("outbox.query", { filters: Array.isArray(filters) ? filters : [filters], ...options ? { options } : {} }),
+      subscribe(filters, options) {
+        const subId = id();
+        const handlers = { event: /* @__PURE__ */ new Set(), closed: /* @__PURE__ */ new Set() };
+        const off = listen((event) => {
+          if (!isParentMessage(event)) return;
+          const msg = event.data;
+          if (typeof msg !== "object" || msg === null || msg.subId !== subId) return;
+          if (msg.type === "outbox.event") for (const handler of handlers.event) handler(msg.result);
+          if (msg.type === "outbox.closed") {
+            for (const handler of handlers.closed) handler(msg.reason);
+            off();
+          }
+        });
+        fire({ type: "outbox.subscribe", id: id(), subId, filters: Array.isArray(filters) ? filters : [filters], ...options ? { options } : {} });
+        return {
+          on(event, handler) {
+            handlers[event].add(handler);
+            return { close: () => handlers[event].delete(handler) };
+          },
+          close() {
+            fire({ type: "outbox.close", id: id(), subId });
+            off();
+            handlers.event.clear();
+            handlers.closed.clear();
+          }
+        };
+      },
+      publish: (event, options) => req("outbox.publish", { event, ...options ? { options } : {} }),
+      resolveRelays: (targetValue) => req("outbox.resolveRelays", { target: targetValue }).then((msg) => msg.plan ?? msg)
+    };
+  }
+  function makeUpload() {
+    return {
+      info: () => request({ type: "upload.info" }, "upload.info.result", (msg) => fieldOrThrow(msg, "info", "upload info unavailable")),
+      upload: (requestPayload) => request({ type: "upload.upload", request: requestPayload }, "upload.upload.result", (msg) => fieldOrThrow(msg, "result", "upload failed")),
+      status: (uploadId) => request({ type: "upload.status", uploadId }, "upload.status.result", (msg) => fieldOrThrow(msg, "status", "upload status unavailable")),
+      onStatus(callback) {
+        const off = listen((event) => {
+          if (!isParentMessage(event)) return;
+          const msg = event.data;
+          if (typeof msg === "object" && msg !== null && msg.type === "upload.status.changed" && msg.status !== void 0) callback(msg.status);
+        });
+        return subscriptionHandle(off);
+      }
+    };
+  }
+  function makeIntent() {
+    const invoke = (requestPayload) => request(
+      { type: "intent.invoke", request: requestPayload },
+      "intent.invoke.result",
+      (msg) => fieldOrThrow(msg, "result", "intent.invoke.result missing result")
+    );
+    return {
+      invoke,
+      open: (archetype, payload, opts) => invoke({
+        archetype,
+        action: "open",
+        payload,
+        ...opts && typeof opts === "object" ? opts : {}
+      }),
+      available: (archetype) => request(
+        { type: "intent.available", archetype },
+        "intent.available.result",
+        (msg) => fieldOrThrow(msg, "availability", "intent.available.result missing availability")
+      ),
+      handlers: () => request(
+        { type: "intent.handlers" },
+        "intent.handlers.result",
+        (msg) => fieldOrThrow(msg, "handlers", "intent.handlers.result missing handlers")
+      ),
+      onChanged: (callback) => domainEventHandle(
+        "intent.changed",
+        callback,
+        (msg) => msg.availability
+      )
+    };
+  }
+  function makeWebrtc() {
+    return {
+      open: (requestPayload) => request(
+        { type: "webrtc.open", request: requestPayload },
+        "webrtc.open.result",
+        (msg) => ({ session: fieldOrThrow(msg, "session", "webrtc.open.result missing session") })
+      ),
+      send: (sessionId, payload) => request(
+        { type: "webrtc.send", sessionId, payload },
+        "webrtc.send.result",
+        (msg) => voidResult(msg, "webrtc send failed")
+      ),
+      close: (sessionId, reason) => request(
+        { type: "webrtc.close", sessionId, ...reason ? { reason } : {} },
+        "webrtc.close.result",
+        (msg) => voidResult(msg, "webrtc close failed")
+      ),
+      onEvent: (callback) => domainEventHandle("webrtc.event", callback)
+    };
+  }
+  function makeBle() {
+    const req = (action, payload, map) => request(
+      { type: `ble.${action}`, ...payload },
+      `ble.${action}.result`,
+      map
+    );
+    return {
+      open: (requestPayload) => req("open", { request: requestPayload }, (msg) => ({ session: fieldOrThrow(msg, "session", "ble.open.result missing session") })),
+      services: (sessionId) => req("services", { sessionId }, (msg) => fieldOrThrow(msg, "services", "ble.services.result missing services")),
+      read: (sessionId, targetValue) => req("read", { sessionId, target: targetValue }, (msg) => fieldOrThrow(msg, "data", "ble.read.result missing data")),
+      write: (sessionId, targetValue, data, options) => req(
+        "write",
+        { sessionId, target: targetValue, data, ...options ? { options } : {} },
+        (msg) => voidResult(msg, "ble write failed")
+      ),
+      subscribe: (sessionId, targetValue) => req("subscribe", { sessionId, target: targetValue }, (msg) => voidResult(msg, "ble subscribe failed")),
+      unsubscribe: (sessionId, targetValue) => req("unsubscribe", { sessionId, target: targetValue }, (msg) => voidResult(msg, "ble unsubscribe failed")),
+      close: (sessionId, reason) => req("close", { sessionId, ...reason ? { reason } : {} }, (msg) => voidResult(msg, "ble close failed")),
+      onEvent: (callback) => domainEventHandle("ble.event", callback)
+    };
+  }
+  function makeSerial() {
+    return {
+      open: (requestPayload) => request(
+        { type: "serial.open", request: requestPayload },
+        "serial.open.result",
+        (msg) => ({ session: fieldOrThrow(msg, "session", "serial.open.result missing session") })
+      ),
+      write: (sessionId, data) => request(
+        { type: "serial.write", sessionId, data: Array.from(data) },
+        "serial.write.result",
+        (msg) => voidResult(msg, "serial write failed")
+      ),
+      close: (sessionId, reason) => request(
+        { type: "serial.close", sessionId, ...reason === void 0 ? {} : { reason } },
+        "serial.close.result",
+        (msg) => voidResult(msg, "serial close failed")
+      ),
+      onEvent: (callback) => domainEventHandle("serial.event", callback)
+    };
+  }
+  function makeLink() {
+    return {
+      open: (url, options) => request(
+        { type: "link.open", url, ...options ? { options } : {} },
+        "link.open.result",
+        resultOrError,
+        { rejectOnError: false }
+      )
+    };
+  }
+  function makeCount() {
+    return {
+      query: (filters, options) => request(
+        { type: "count.query", filters: Array.isArray(filters) ? filters : [filters], ...options ? { options } : {} },
+        "count.query.result",
+        resultOrError,
+        { rejectOnError: false }
+      )
+    };
+  }
+  function makeLists() {
+    const req = (type, payload) => request({ type, ...payload }, `${type}.result`, resultOrError, { rejectOnError: false });
+    return {
+      supported: () => req("lists.supported", {}),
+      add: (list, items, options) => req("lists.add", { list, items, ...options ? { options } : {} }),
+      remove: (list, items, options) => req("lists.remove", { list, items, ...options ? { options } : {} })
+    };
+  }
+  function makeCommon() {
+    const req = (type, payload) => request({ type, ...payload }, `${type}.result`, withoutEnvelope, { rejectOnError: false });
+    return {
+      encodeNip19: (input) => req("common.encodeNip19", { input }),
+      decodeNip19: (value) => req("common.decodeNip19", { value }),
+      getProfile: (targetValue) => req("common.getProfile", { target: targetValue }),
+      follows: () => req("common.follows", {}),
+      follow: (...pubkeys) => req("common.follow", { pubkeys }),
+      unfollow: (...pubkeys) => req("common.unfollow", { pubkeys }),
+      react: (targetEventId, reaction, customEmojiHref) => req("common.react", {
+        targetEventId,
+        reaction,
+        ...customEmojiHref === void 0 ? {} : { customEmojiHref }
+      }),
+      report: (targetValue, reason, text) => req("common.report", {
+        target: targetValue,
+        reason,
+        text
+      })
+    };
+  }
+  function makeDm() {
+    const req = (type, payload) => request({ type, ...payload }, `${type}.result`, withoutEnvelope, { rejectOnError: false });
+    return {
+      status: () => req("dm.status", {}),
+      conversations: (query) => req("dm.conversations", query ?? {}),
+      messages: (query) => req("dm.messages", query ?? {}),
+      send: (requestPayload) => req("dm.send", requestPayload ?? {}),
+      subscribe: (requestPayload) => req("dm.subscribe", requestPayload ?? {}),
+      unsubscribe: (subscriptionId) => req("dm.unsubscribe", { subscriptionId }),
+      onMessage(callback) {
+        const off = listen((event) => {
+          if (!isParentMessage(event)) return;
+          const msg = event.data;
+          if (typeof msg === "object" && msg !== null && msg.type === "dm.message" && typeof msg.subscriptionId === "string") {
+            callback(msg.message, msg.subscriptionId);
+          }
+        });
+        return subscriptionHandle(off);
+      }
+    };
+  }
+  function makeDomain(domain, existing) {
+    if (existing && typeof existing === "object" && Object.keys(existing).length > 0) return existing;
+    switch (domain) {
+      case "relay":
+        return makeRelay();
+      case "inc":
+        return makeInc();
+      case "storage":
+        return makeStorage();
+      case "keys":
+        return makeKeys();
+      case "media":
+        return makeMedia();
+      case "notify":
+        return makeNotify();
+      case "identity":
+        return makeIdentity();
+      case "theme":
+        return makeTheme();
+      case "config":
+        return makeConfig();
+      case "resource":
+        return makeResource();
+      case "cvm":
+        return makeCvm();
+      case "outbox":
+        return makeOutbox();
+      case "upload":
+        return makeUpload();
+      case "intent":
+        return makeIntent();
+      case "webrtc":
+        return makeWebrtc();
+      case "ble":
+        return makeBle();
+      case "link":
+        return makeLink();
+      case "count":
+        return makeCount();
+      case "lists":
+        return makeLists();
+      case "common":
+        return makeCommon();
+      case "serial":
+        return makeSerial();
+      case "dm":
+        return makeDm();
+      default:
+        return {};
+    }
+  }
+  function guardNappletNamespace(namespace) {
+    return new Proxy(namespace, {
+      set(obj, prop, value) {
+        if (typeof prop !== "string" || !allowed.has(prop)) return true;
+        obj[prop] = makeDomain(prop, value);
+        return true;
+      },
+      defineProperty(obj, prop, descriptor) {
+        if (typeof prop !== "string" || !allowed.has(prop)) return true;
+        return Reflect.defineProperty(obj, prop, {
+          ...descriptor,
+          value: makeDomain(prop, descriptor.value)
+        });
+      }
+    });
+  }
   function buildNappletNamespace(value) {
     const candidate = typeof value === "object" && value !== null ? value : {};
     const next = {};
     for (const domain of domains) {
+      if (!allowed.has(domain)) continue;
       Object.defineProperty(next, domain, {
-        value: Object.prototype.hasOwnProperty.call(candidate, domain) ? candidate[domain] : {},
+        value: makeDomain(
+          domain,
+          Object.prototype.hasOwnProperty.call(candidate, domain) ? candidate[domain] : void 0
+        ),
         enumerable: true,
         configurable: true,
         writable: true
       });
     }
-    return next;
+    return guardNappletNamespace(next);
   }
   let root = buildNappletNamespace(target.napplet);
   Object.defineProperty(target, "napplet", {