@kehto/shell 0.1.0

package/dist/index.js

@@ -0,0 +1,1129 @@
+// src/shell-bridge.ts
+import { createRuntime } from "@kehto/runtime";
+
+// src/hooks-adapter.ts
+function bytesToHex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+function adaptHooks(shellHooks, deps) {
+  const { originRegistry: originRegistry2 } = deps;
+  const sendToNapplet = (windowId, msg) => {
+    const win = originRegistry2.getIframeWindow(windowId);
+    if (win) win.postMessage(msg, "*");
+  };
+  const relayPool = {
+    subscribe(filters, callback, relayUrls) {
+      const pool = shellHooks.relayPool.getRelayPool();
+      if (!pool) return { unsubscribe() {
+      } };
+      const urls = relayUrls ?? shellHooks.relayPool.selectRelayTier(filters);
+      const sub = pool.subscription(urls, filters).subscribe((item) => {
+        if (item === "EOSE") {
+          callback("EOSE");
+        } else {
+          callback(item);
+        }
+      });
+      return { unsubscribe: () => sub.unsubscribe() };
+    },
+    publish(event) {
+      const pool = shellHooks.relayPool.getRelayPool();
+      if (!pool) return;
+      const relayUrls = shellHooks.relayPool.selectRelayTier([]);
+      pool.publish(relayUrls, event);
+    },
+    selectRelayTier(filters) {
+      return shellHooks.relayPool.selectRelayTier(filters);
+    },
+    trackSubscription(subKey, cleanup) {
+      shellHooks.relayPool.trackSubscription(subKey, cleanup);
+    },
+    untrackSubscription(subKey) {
+      shellHooks.relayPool.untrackSubscription(subKey);
+    },
+    openScopedRelay(windowId, relayUrl, subId, filters, sendFn) {
+      const win = originRegistry2.getIframeWindow(windowId);
+      if (win) shellHooks.relayPool.openScopedRelay(windowId, relayUrl, subId, filters, win);
+    },
+    closeScopedRelay(windowId) {
+      shellHooks.relayPool.closeScopedRelay(windowId);
+    },
+    publishToScopedRelay(windowId, event) {
+      return shellHooks.relayPool.publishToScopedRelay(windowId, event);
+    },
+    isAvailable() {
+      return shellHooks.relayPool.getRelayPool() !== null;
+    }
+  };
+  const cache2 = {
+    async query(filters) {
+      const workerRelay = shellHooks.workerRelay.getWorkerRelay();
+      if (!workerRelay) return [];
+      const subId = crypto.randomUUID();
+      return workerRelay.query(["REQ", subId, ...filters]);
+    },
+    store(event) {
+      const workerRelay = shellHooks.workerRelay.getWorkerRelay();
+      if (!workerRelay) return;
+      try {
+        workerRelay.event(event)?.catch?.(() => {
+        });
+      } catch {
+      }
+    },
+    isAvailable() {
+      return shellHooks.workerRelay.getWorkerRelay() !== null;
+    }
+  };
+  const auth = {
+    getUserPubkey() {
+      return shellHooks.auth.getUserPubkey();
+    },
+    getSigner() {
+      return shellHooks.auth.getSigner();
+    }
+  };
+  const config = {
+    getNappUpdateBehavior() {
+      return shellHooks.config.getNappUpdateBehavior();
+    }
+  };
+  const hotkeys = {
+    executeHotkeyFromForward(event) {
+      shellHooks.hotkeys.executeHotkeyFromForward(event);
+    }
+  };
+  const cryptoHooks = {
+    async verifyEvent(event) {
+      return shellHooks.crypto.verifyEvent(event);
+    },
+    randomUUID() {
+      return crypto.randomUUID();
+    },
+    randomBytes(length) {
+      const bytes = new Uint8Array(length);
+      crypto.getRandomValues(bytes);
+      return bytes;
+    }
+  };
+  const aclPersistence = {
+    persist(data) {
+      try {
+        localStorage.setItem("napplet:acl", data);
+      } catch {
+      }
+    },
+    load() {
+      try {
+        return localStorage.getItem("napplet:acl");
+      } catch {
+        return null;
+      }
+    }
+  };
+  const manifestPersistence = {
+    persist(data) {
+      try {
+        localStorage.setItem("napplet:manifest-cache", data);
+      } catch {
+      }
+    },
+    load() {
+      try {
+        return localStorage.getItem("napplet:manifest-cache");
+      } catch {
+        return null;
+      }
+    }
+  };
+  const statePersistence = {
+    get(scopedKey) {
+      try {
+        return localStorage.getItem(scopedKey);
+      } catch {
+        return null;
+      }
+    },
+    set(scopedKey, value) {
+      try {
+        localStorage.setItem(scopedKey, value);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    remove(scopedKey) {
+      try {
+        localStorage.removeItem(scopedKey);
+      } catch {
+      }
+    },
+    clear(prefix) {
+      try {
+        const keysToRemove = [];
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (key?.startsWith(prefix)) keysToRemove.push(key);
+        }
+        for (const key of keysToRemove) localStorage.removeItem(key);
+      } catch {
+      }
+    },
+    keys(prefix) {
+      try {
+        const result = [];
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (key?.startsWith(prefix)) result.push(key);
+        }
+        return result;
+      } catch {
+        return [];
+      }
+    },
+    calculateBytes(prefix, excludeKey) {
+      try {
+        let total = 0;
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (!key?.startsWith(prefix)) continue;
+          if (excludeKey && key === excludeKey) continue;
+          const value = localStorage.getItem(key) ?? "";
+          total += new TextEncoder().encode(key + value).length;
+        }
+        return total;
+      } catch {
+        return 0;
+      }
+    }
+  };
+  const windowManager = {
+    createWindow(options) {
+      return shellHooks.windowManager.createWindow(options);
+    }
+  };
+  const relayConfig = {
+    addRelay(tier, url) {
+      shellHooks.relayConfig.addRelay(tier, url);
+    },
+    removeRelay(tier, url) {
+      shellHooks.relayConfig.removeRelay(tier, url);
+    },
+    getRelayConfig() {
+      return shellHooks.relayConfig.getRelayConfig();
+    },
+    getNip66Suggestions() {
+      return shellHooks.relayConfig.getNip66Suggestions();
+    }
+  };
+  const shellSecretPersistence = {
+    get() {
+      try {
+        const hex = localStorage.getItem("napplet-shell-secret");
+        if (!hex) return null;
+        return hexToBytes(hex);
+      } catch {
+        return null;
+      }
+    },
+    set(secret) {
+      try {
+        localStorage.setItem("napplet-shell-secret", bytesToHex(secret));
+      } catch {
+      }
+    }
+  };
+  const guidPersistence = {
+    get(windowId) {
+      try {
+        return localStorage.getItem(`napplet-guid:${windowId}`);
+      } catch {
+        return null;
+      }
+    },
+    set(windowId, guid) {
+      try {
+        localStorage.setItem(`napplet-guid:${windowId}`, guid);
+      } catch {
+      }
+    },
+    remove(windowId) {
+      try {
+        localStorage.removeItem(`napplet-guid:${windowId}`);
+      } catch {
+      }
+    }
+  };
+  const dm = shellHooks.dm ? {
+    sendDm(recipientPubkey, message) {
+      return shellHooks.dm.sendDm(recipientPubkey, message);
+    }
+  } : void 0;
+  return {
+    sendToNapplet,
+    relayPool,
+    cache: cache2,
+    auth,
+    config,
+    hotkeys,
+    crypto: cryptoHooks,
+    aclPersistence,
+    manifestPersistence,
+    statePersistence,
+    windowManager,
+    relayConfig,
+    dm,
+    shellSecretPersistence,
+    guidPersistence,
+    onAclCheck: shellHooks.onAclCheck,
+    onHashMismatch: shellHooks.onHashMismatch,
+    services: shellHooks.services,
+    getConfigOverrides: shellHooks.getConfigOverrides
+  };
+}
+
+// src/origin-registry.ts
+var registry = /* @__PURE__ */ new Map();
+var originRegistry = {
+  /**
+   * Register a window reference with a windowId and optional identity metadata.
+   *
+   * @param win - The iframe's contentWindow reference
+   * @param windowId - The unique identifier for this napplet window
+   * @param identity - Optional NIP-5D identity metadata (dTag and aggregateHash)
+   */
+  register(win, windowId, identity) {
+    registry.set(win, {
+      windowId,
+      dTag: identity?.dTag,
+      aggregateHash: identity?.aggregateHash
+    });
+  },
+  /**
+   * Unregister a window by its windowId, removing the mapping.
+   *
+   * @param windowId - The window identifier to remove
+   */
+  unregister(windowId) {
+    for (const [win, entry] of registry.entries()) {
+      if (entry.windowId === windowId) {
+        registry.delete(win);
+      }
+    }
+  },
+  /**
+   * Look up the windowId for a given Window reference.
+   *
+   * @param win - The Window reference (typically from event.source)
+   * @returns The windowId string, or undefined if not registered
+   */
+  getWindowId(win) {
+    return registry.get(win)?.windowId;
+  },
+  /**
+   * Look up the Window reference for a given windowId.
+   *
+   * @param windowId - The window identifier to look up
+   * @returns The Window reference, or null if not found
+   */
+  getIframeWindow(windowId) {
+    for (const [win, entry] of registry.entries()) {
+      if (entry.windowId === windowId) return win;
+    }
+    return null;
+  },
+  /**
+   * Get all registered windowId strings.
+   *
+   * @returns Array of all registered window identifiers
+   */
+  getAllWindowIds() {
+    return Array.from(registry.values()).map((entry) => entry.windowId);
+  },
+  /**
+   * Get identity metadata for a registered Window.
+   *
+   * @param win - The Window reference to look up
+   * @returns Identity metadata, or undefined if not registered or no identity set
+   */
+  getIdentity(win) {
+    const entry = registry.get(win);
+    if (!entry?.dTag || !entry?.aggregateHash) return void 0;
+    return { dTag: entry.dTag, aggregateHash: entry.aggregateHash };
+  },
+  /** Clear all registrations. */
+  clear() {
+    registry.clear();
+  }
+};
+
+// src/session-registry.ts
+var byWindowId = /* @__PURE__ */ new Map();
+var byPubkey = /* @__PURE__ */ new Map();
+var pendingUpdates = /* @__PURE__ */ new Map();
+var _pendingVersion = 0;
+var sessionRegistry = {
+  /**
+   * Register a napplet entry, mapping windowId to pubkey and vice versa.
+   *
+   * @param windowId - The window identifier
+   * @param entry - The verified napplet session entry from AUTH handshake
+   */
+  register(windowId, entry) {
+    byWindowId.set(windowId, entry.pubkey);
+    byPubkey.set(entry.pubkey, entry);
+  },
+  /**
+   * Unregister a napplet by windowId, removing both mappings.
+   *
+   * @param windowId - The window identifier to remove
+   */
+  unregister(windowId) {
+    const pubkey = byWindowId.get(windowId);
+    if (pubkey) {
+      byPubkey.delete(pubkey);
+      byWindowId.delete(windowId);
+    }
+    pendingUpdates.delete(windowId);
+  },
+  /**
+   * Get the pubkey associated with a windowId.
+   *
+   * @param windowId - The window identifier
+   * @returns The napplet's pubkey, or undefined if not registered
+   */
+  getPubkey(windowId) {
+    return byWindowId.get(windowId);
+  },
+  /**
+   * Get the full entry for a napplet pubkey.
+   *
+   * @param pubkey - The napplet's pubkey
+   * @returns The full SessionEntry, or undefined if not found
+   */
+  getEntry(pubkey) {
+    return byPubkey.get(pubkey);
+  },
+  /**
+   * Get the windowId for a napplet pubkey.
+   *
+   * @param pubkey - The napplet's pubkey
+   * @returns The windowId, or undefined if not found
+   */
+  getWindowId(pubkey) {
+    return byPubkey.get(pubkey)?.windowId;
+  },
+  /**
+   * Check if a windowId has a registered napplet.
+   *
+   * @param windowId - The window identifier
+   * @returns True if the windowId has a registered napplet
+   */
+  isRegistered(windowId) {
+    return byWindowId.has(windowId);
+  },
+  /**
+   * Get all registered napplet entries.
+   *
+   * @returns Array of all SessionEntry objects
+   */
+  getAllEntries() {
+    return Array.from(byPubkey.values());
+  },
+  /**
+   * Set a pending update for a window (napplet reconnected with different hash).
+   *
+   * @param windowId - The window identifier
+   * @param update - The pending update details with resolve callback
+   */
+  setPendingUpdate(windowId, update) {
+    pendingUpdates.set(windowId, update);
+    _pendingVersion++;
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new CustomEvent("napplet:pending-update", { detail: { windowId } }));
+    }
+  },
+  /**
+   * Get a pending update for a window.
+   *
+   * @param windowId - The window identifier
+   * @returns The pending update, or undefined if none
+   */
+  getPendingUpdate(windowId) {
+    return pendingUpdates.get(windowId);
+  },
+  /**
+   * Clear a pending update for a window.
+   *
+   * @param windowId - The window identifier
+   */
+  clearPendingUpdate(windowId) {
+    pendingUpdates.delete(windowId);
+    _pendingVersion++;
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new CustomEvent("napplet:pending-update", { detail: { windowId } }));
+    }
+  },
+  /** Clear all registrations and pending updates. */
+  clear() {
+    byWindowId.clear();
+    byPubkey.clear();
+    pendingUpdates.clear();
+  }
+};
+var nappKeyRegistry = sessionRegistry;
+
+// src/acl-store.ts
+import { ALL_CAPABILITIES } from "@kehto/runtime";
+import { migrateAclState } from "@kehto/acl";
+var STORAGE_KEY = "napplet:acl";
+var DEFAULT_STATE_QUOTA = 512 * 1024;
+function aclKey(_pubkey, dTag, aggregateHash) {
+  return `${dTag}:${aggregateHash}`;
+}
+var store = /* @__PURE__ */ new Map();
+var CAP_BITS = {
+  "relay:read": 1,
+  "relay:write": 2,
+  "cache:read": 4,
+  "cache:write": 8,
+  "hotkey:forward": 16,
+  "identity:read": 32,
+  "keys:bind": 64,
+  "keys:forward": 128,
+  "state:read": 256,
+  "state:write": 512,
+  "media:control": 1024,
+  "notify:send": 2048,
+  "notify:channel": 4096,
+  "theme:read": 8192
+};
+function capArrayToBitfield(caps) {
+  let bits = 0;
+  for (const cap of caps) bits |= CAP_BITS[cap] ?? 0;
+  return bits;
+}
+function bitfieldToCapArray(bits) {
+  return Object.entries(CAP_BITS).filter(([, bit]) => (bits & bit) !== 0).map(([name]) => name);
+}
+function getOrCreate(pubkey, dTag, aggregateHash) {
+  const key = aclKey(pubkey, dTag, aggregateHash);
+  let entry = store.get(key);
+  if (!entry) {
+    entry = {
+      key,
+      pubkey,
+      dTag,
+      aggregateHash,
+      capabilities: new Set(ALL_CAPABILITIES),
+      blocked: false,
+      stateQuota: DEFAULT_STATE_QUOTA
+    };
+    store.set(key, entry);
+  }
+  return entry;
+}
+var aclStore = {
+  /**
+   * Check if a napp identity has a specific capability.
+   * Returns true for unknown identities (permissive default).
+   *
+   * @param pubkey - The napp's pubkey
+   * @param dTag - The napp's dTag
+   * @param aggregateHash - The napp's build hash
+   * @param capability - The capability to check
+   * @returns True if the capability is granted and the napp is not blocked
+   */
+  check(pubkey, dTag, aggregateHash, capability) {
+    const key = aclKey(pubkey, dTag, aggregateHash);
+    const entry = store.get(key);
+    if (!entry) return true;
+    if (entry.blocked) return false;
+    return entry.capabilities.has(capability);
+  },
+  /**
+   * Grant a capability to a napp identity.
+   *
+   * @param pubkey - The napp's pubkey
+   * @param dTag - The napp's dTag
+   * @param aggregateHash - The napp's build hash
+   * @param capability - The capability to grant
+   */
+  grant(pubkey, dTag, aggregateHash, capability) {
+    getOrCreate(pubkey, dTag, aggregateHash).capabilities.add(capability);
+  },
+  /**
+   * Revoke a capability from a napp identity.
+   *
+   * @param pubkey - The napp's pubkey
+   * @param dTag - The napp's dTag
+   * @param aggregateHash - The napp's build hash
+   * @param capability - The capability to revoke
+   */
+  revoke(pubkey, dTag, aggregateHash, capability) {
+    getOrCreate(pubkey, dTag, aggregateHash).capabilities.delete(capability);
+  },
+  /**
+   * Block a napp identity entirely (all capabilities denied).
+   *
+   * @param pubkey - The napp's pubkey
+   * @param dTag - The napp's dTag
+   * @param aggregateHash - The napp's build hash
+   */
+  block(pubkey, dTag, aggregateHash) {
+    getOrCreate(pubkey, dTag, aggregateHash).blocked = true;
+  },
+  /**
+   * Unblock a napp identity.
+   *
+   * @param pubkey - The napp's pubkey
+   * @param dTag - The napp's dTag
+   * @param aggregateHash - The napp's build hash
+   */
+  unblock(pubkey, dTag, aggregateHash) {
+    getOrCreate(pubkey, dTag, aggregateHash).blocked = false;
+  },
+  /**
+   * Check if a napp identity is blocked.
+   *
+   * @param pubkey - The napp's pubkey
+   * @param dTag - The napp's dTag
+   * @param aggregateHash - The napp's build hash
+   * @returns True if the identity is blocked
+   */
+  isBlocked(pubkey, dTag, aggregateHash) {
+    const key = aclKey(pubkey, dTag, aggregateHash);
+    return store.get(key)?.blocked ?? false;
+  },
+  /**
+   * Get the external ACL entry for a napp identity.
+   *
+   * @param pubkey - The napp's pubkey
+   * @param dTag - The napp's dTag
+   * @param aggregateHash - The napp's build hash
+   * @returns The ACL entry, or undefined if no explicit entry exists
+   */
+  getEntry(pubkey, dTag, aggregateHash) {
+    const key = aclKey(pubkey, dTag, aggregateHash);
+    const internal = store.get(key);
+    if (!internal) return void 0;
+    return {
+      pubkey: internal.pubkey,
+      capabilities: Array.from(internal.capabilities),
+      blocked: internal.blocked,
+      stateQuota: internal.stateQuota
+    };
+  },
+  /**
+   * Get all ACL entries.
+   *
+   * @returns Array of all ACL entries
+   */
+  getAllEntries() {
+    return Array.from(store.values()).map((e) => ({
+      pubkey: e.pubkey,
+      capabilities: Array.from(e.capabilities),
+      blocked: e.blocked,
+      stateQuota: e.stateQuota
+    }));
+  },
+  /** Persist the ACL store to localStorage. */
+  persist() {
+    try {
+      const entries = Array.from(store.entries()).map(([key, val]) => [
+        key,
+        {
+          pubkey: val.pubkey,
+          dTag: val.dTag,
+          aggregateHash: val.aggregateHash,
+          capabilities: Array.from(val.capabilities),
+          blocked: val.blocked,
+          stateQuota: val.stateQuota
+        }
+      ]);
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(entries));
+    } catch {
+    }
+  },
+  /** Load the ACL store from localStorage. Migrates old 3-segment keys to 2-segment format. */
+  load() {
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY);
+      if (!raw) return;
+      let entries = JSON.parse(raw);
+      const hasOldKeys = entries.some(([key]) => key.split(":").length === 3);
+      if (hasOldKeys) {
+        const tempState = {
+          defaultPolicy: "permissive",
+          entries: Object.fromEntries(
+            entries.map(([key, val]) => [key, {
+              caps: capArrayToBitfield(val.capabilities),
+              blocked: val.blocked,
+              quota: val.stateQuota ?? DEFAULT_STATE_QUOTA
+            }])
+          )
+        };
+        const migrated = migrateAclState(tempState);
+        if (migrated !== tempState) {
+          entries = Object.entries(migrated.entries).map(([key, entry]) => {
+            const parts = key.split(":");
+            return [key, {
+              pubkey: "",
+              dTag: parts[0] ?? "",
+              aggregateHash: parts[1] ?? "",
+              capabilities: bitfieldToCapArray(entry.caps),
+              blocked: entry.blocked,
+              stateQuota: entry.quota
+            }];
+          });
+          localStorage.setItem(STORAGE_KEY, JSON.stringify(entries));
+        }
+      }
+      store.clear();
+      for (const [key, val] of entries) {
+        if (val.dTag === void 0 || val.aggregateHash === void 0) continue;
+        store.set(key, {
+          key,
+          pubkey: val.pubkey,
+          dTag: val.dTag,
+          aggregateHash: val.aggregateHash,
+          capabilities: new Set(val.capabilities),
+          blocked: val.blocked,
+          stateQuota: val.stateQuota ?? DEFAULT_STATE_QUOTA
+        });
+      }
+    } catch {
+      store.clear();
+    }
+  },
+  /**
+   * Get the state quota for a napp identity.
+   *
+   * @param pubkey - The napp's pubkey
+   * @param dTag - The napp's dTag
+   * @param aggregateHash - The napp's build hash
+   * @returns The quota in bytes (defaults to DEFAULT_STATE_QUOTA)
+   */
+  getStateQuota(pubkey, dTag, aggregateHash) {
+    const key = aclKey(pubkey, dTag, aggregateHash);
+    return store.get(key)?.stateQuota ?? DEFAULT_STATE_QUOTA;
+  },
+  /** Clear all ACL entries and remove from localStorage. */
+  clear() {
+    store.clear();
+    try {
+      localStorage.removeItem(STORAGE_KEY);
+    } catch {
+    }
+  }
+};
+
+// src/manifest-cache.ts
+var STORAGE_KEY2 = "napplet:manifest-cache";
+var cache = /* @__PURE__ */ new Map();
+function cacheKey(pubkey, dTag) {
+  return `${pubkey}:${dTag}`;
+}
+var manifestCache = {
+  /**
+   * Get a cached manifest entry by pubkey and dTag.
+   *
+   * @param pubkey - The napp's pubkey
+   * @param dTag - The napp's dTag
+   * @returns The cached entry, or undefined if not found
+   */
+  get(pubkey, dTag) {
+    return cache.get(cacheKey(pubkey, dTag));
+  },
+  /**
+   * Set (upsert) a manifest cache entry and persist to localStorage.
+   *
+   * @param entry - The manifest entry to cache
+   */
+  set(entry) {
+    cache.set(cacheKey(entry.pubkey, entry.dTag), entry);
+    manifestCache.persist();
+  },
+  /**
+   * Check if a specific hash is cached for a pubkey/dTag combination.
+   *
+   * @param pubkey - The napp's pubkey
+   * @param dTag - The napp's dTag
+   * @param hash - The aggregateHash to check
+   * @returns True if the exact hash matches the cached entry
+   */
+  has(pubkey, dTag, hash) {
+    const entry = cache.get(cacheKey(pubkey, dTag));
+    return !!entry && entry.aggregateHash === hash;
+  },
+  /**
+   * Remove a cached entry for a pubkey/dTag and persist.
+   *
+   * @param pubkey - The napp's pubkey
+   * @param dTag - The napp's dTag
+   */
+  remove(pubkey, dTag) {
+    cache.delete(cacheKey(pubkey, dTag));
+    manifestCache.persist();
+  },
+  /** Load the cache from localStorage. */
+  load() {
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY2);
+      if (!raw) return;
+      const entries = JSON.parse(raw);
+      cache.clear();
+      for (const [key, val] of entries) cache.set(key, val);
+    } catch {
+      cache.clear();
+    }
+  },
+  /** Persist the cache to localStorage. */
+  persist() {
+    try {
+      localStorage.setItem(STORAGE_KEY2, JSON.stringify(Array.from(cache.entries())));
+    } catch {
+    }
+  },
+  /** Clear all cached entries and remove from localStorage. */
+  clear() {
+    cache.clear();
+    try {
+      localStorage.removeItem(STORAGE_KEY2);
+    } catch {
+    }
+  }
+};
+
+// src/audio-manager.ts
+var sources = /* @__PURE__ */ new Map();
+var version = 0;
+function bump() {
+  version++;
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new CustomEvent("napplet:audio-changed"));
+  }
+}
+var audioManager = {
+  /**
+   * Register a new audio source for a window.
+   *
+   * @param windowId - The window identifier
+   * @param nappletClass - The napplet class/type (e.g., 'music-player')
+   * @param title - Human-readable title for the audio source
+   */
+  register(windowId, nappletClass, title) {
+    sources.set(windowId, { windowId, nappletClass, title, muted: false });
+    bump();
+  },
+  /**
+   * Unregister an audio source for a window.
+   *
+   * @param windowId - The window identifier to remove
+   */
+  unregister(windowId) {
+    if (sources.delete(windowId)) bump();
+  },
+  /**
+   * Update the state of an audio source (e.g., change title).
+   *
+   * @param windowId - The window identifier
+   * @param update - Partial update with optional title
+   */
+  updateState(windowId, update) {
+    const src = sources.get(windowId);
+    if (!src) return;
+    if (update.title !== void 0) src.title = update.title;
+    bump();
+  },
+  /**
+   * Mute or unmute an audio source and notify the napplet via postMessage.
+   *
+   * @param windowId - The window identifier
+   * @param muted - True to mute, false to unmute
+   * @example
+   * ```ts
+   * audioManager.mute('win-1', true); // mute
+   * audioManager.mute('win-1', false); // unmute
+   * ```
+   */
+  mute(windowId, muted) {
+    const src = sources.get(windowId);
+    if (src) {
+      src.muted = muted;
+      bump();
+    }
+    const iframeWindow = originRegistry.getIframeWindow(windowId);
+    if (iframeWindow) {
+      const muteEvent = {
+        kind: 29e3,
+        // IPC_PEER — inlined numeric after Phase 24 DRIFT-01 shim removal
+        created_at: Math.floor(Date.now() / 1e3),
+        tags: [["t", "napplet:audio-muted"]],
+        content: JSON.stringify({ muted }),
+        pubkey: "__shell__",
+        id: `audio-mute-${windowId}-${Date.now()}`,
+        sig: ""
+      };
+      iframeWindow.postMessage(["EVENT", "__shell__", muteEvent], "*");
+    }
+  },
+  /**
+   * Check if a window has a registered audio source.
+   *
+   * @param windowId - The window identifier
+   * @returns True if the window has an active audio source
+   */
+  has(windowId) {
+    return sources.has(windowId);
+  },
+  /**
+   * Get the audio source for a window.
+   *
+   * @param windowId - The window identifier
+   * @returns The AudioSource, or undefined if not found
+   */
+  get(windowId) {
+    return sources.get(windowId);
+  },
+  /**
+   * Get a snapshot of all audio sources.
+   *
+   * @returns A new Map of all active audio sources
+   */
+  getSources() {
+    return new Map(sources);
+  },
+  /** Current version counter (incremented on every change). */
+  get version() {
+    return version;
+  },
+  /** Number of active audio sources. */
+  get count() {
+    return sources.size;
+  },
+  /** Clear all audio sources and reset version counter. */
+  clear() {
+    sources.clear();
+    version = 0;
+  }
+};
+
+// src/shell-init.ts
+var CANONICAL_NUB_DOMAINS = [
+  "identity",
+  "storage",
+  "ifc",
+  "theme",
+  "keys",
+  "media",
+  "notify"
+];
+function buildShellCapabilities(hooks) {
+  const nubs = hooks.relayPool ? ["relay", ...CANONICAL_NUB_DOMAINS] : [...CANONICAL_NUB_DOMAINS];
+  return { nubs, sandbox: [] };
+}
+
+// src/keys-forwarder.ts
+function createKeysForwarder(deps) {
+  const target = deps.target ?? (typeof window !== "undefined" ? window : new EventTarget());
+  const listener = (ev) => {
+    const ke = ev;
+    const entries = deps.sessionRegistry.getAllEntries();
+    for (const entry of entries) {
+      if (!deps.hasKeysForwardCap(entry.pubkey)) continue;
+      const iframe = deps.originRegistry.getIframeWindow(entry.windowId);
+      if (!iframe) continue;
+      const envelope = {
+        type: "keys.forward",
+        key: ke.key ?? "",
+        code: ke.code ?? "",
+        ctrl: ke.ctrlKey ?? false,
+        alt: ke.altKey ?? false,
+        shift: ke.shiftKey ?? false,
+        meta: ke.metaKey ?? false
+      };
+      iframe.postMessage(envelope, "*");
+    }
+  };
+  target.addEventListener("keydown", listener);
+  return {
+    destroy() {
+      target.removeEventListener("keydown", listener);
+    }
+  };
+}
+
+// src/shell-bridge.ts
+function createShellBridge(hooks) {
+  const runtimeHooks = adaptHooks(hooks, {
+    originRegistry,
+    manifestCache,
+    aclStore,
+    audioManager,
+    nappKeyRegistry
+  });
+  const runtime = createRuntime(runtimeHooks);
+  let keysForwarder = null;
+  if (typeof window !== "undefined") {
+    try {
+      keysForwarder = createKeysForwarder({
+        originRegistry,
+        sessionRegistry,
+        hasKeysForwardCap: (pubkey) => {
+          const entry = sessionRegistry.getEntry(pubkey);
+          if (!entry) return false;
+          const acl = aclStore.getEntry(entry.pubkey, entry.dTag, entry.aggregateHash);
+          return acl?.capabilities.includes("keys:forward") ?? false;
+        }
+      });
+    } catch {
+      keysForwarder = null;
+    }
+  }
+  return {
+    handleMessage(event) {
+      const sourceWindow = event.source;
+      if (!sourceWindow) return;
+      const windowId = originRegistry.getWindowId(sourceWindow);
+      if (!windowId) return;
+      const msg = event.data;
+      if (typeof msg !== "object" || msg === null || typeof msg.type !== "string") return;
+      if (msg.type === "shell.ready") {
+        const capabilities = buildShellCapabilities(hooks);
+        const initMsg = {
+          type: "shell.init",
+          capabilities,
+          services: Object.keys(hooks.services ?? {})
+        };
+        const win = originRegistry.getIframeWindow(windowId);
+        if (win) win.postMessage(initMsg, "*");
+        return;
+      }
+      runtime.handleMessage(windowId, msg);
+    },
+    injectEvent(topic, payload) {
+      runtime.injectEvent(topic, payload);
+    },
+    destroy() {
+      keysForwarder?.destroy();
+      runtime.destroy();
+    },
+    registerConsentHandler(handler) {
+      runtime.registerConsentHandler(handler);
+    },
+    publishTheme(theme) {
+      const envelope = { type: "theme.changed", theme };
+      const windowIds = originRegistry.getAllWindowIds();
+      for (const windowId of windowIds) {
+        const win = originRegistry.getIframeWindow(windowId);
+        if (!win) continue;
+        win.postMessage(envelope, "*");
+      }
+    },
+    get runtime() {
+      return runtime;
+    }
+  };
+}
+
+// src/index.ts
+import { ALL_CAPABILITIES as ALL_CAPABILITIES2 } from "@kehto/runtime";
+import { createEnforceGate, createNubEnforceGate, formatDenialReason } from "@kehto/runtime";
+
+// src/topics.ts
+import { TOPICS } from "@napplet/core";
+
+// src/identity-proxy.ts
+function createIdentityProxy(deps) {
+  return {
+    dispatch(windowId, envelope) {
+      deps.runtime.handleMessage(windowId, envelope);
+    },
+    emit(windowId, envelope) {
+      const win = deps.originRegistry.getIframeWindow(windowId);
+      if (win) win.postMessage(envelope, "*");
+    }
+  };
+}
+
+// src/theme-proxy.ts
+function createThemeProxy(deps) {
+  return {
+    dispatch(windowId, envelope) {
+      deps.runtime.handleMessage(windowId, envelope);
+    },
+    emit(windowId, envelope) {
+      const win = deps.originRegistry.getIframeWindow(windowId);
+      if (win) win.postMessage(envelope, "*");
+    }
+  };
+}
+
+// src/keys-proxy.ts
+function createKeysProxy(deps) {
+  return {
+    dispatch(windowId, envelope) {
+      deps.runtime.handleMessage(windowId, envelope);
+    },
+    emit(windowId, envelope) {
+      const win = deps.originRegistry.getIframeWindow(windowId);
+      if (win) win.postMessage(envelope, "*");
+    }
+  };
+}
+
+// src/media-proxy.ts
+function createMediaProxy(deps) {
+  return {
+    dispatch(windowId, envelope) {
+      deps.runtime.handleMessage(windowId, envelope);
+    },
+    emit(windowId, envelope) {
+      const win = deps.originRegistry.getIframeWindow(windowId);
+      if (win) win.postMessage(envelope, "*");
+    }
+  };
+}
+
+// src/notify-proxy.ts
+function createNotifyProxy(deps) {
+  return {
+    dispatch(windowId, envelope) {
+      deps.runtime.handleMessage(windowId, envelope);
+    },
+    emit(windowId, envelope) {
+      const win = deps.originRegistry.getIframeWindow(windowId);
+      if (win) win.postMessage(envelope, "*");
+    }
+  };
+}
+export {
+  ALL_CAPABILITIES2 as ALL_CAPABILITIES,
+  TOPICS,
+  adaptHooks,
+  audioManager,
+  buildShellCapabilities,
+  createEnforceGate,
+  createIdentityProxy,
+  createKeysForwarder,
+  createKeysProxy,
+  createMediaProxy,
+  createNotifyProxy,
+  createNubEnforceGate,
+  createShellBridge,
+  createThemeProxy,
+  formatDenialReason,
+  manifestCache,
+  nappKeyRegistry,
+  originRegistry,
+  sessionRegistry
+};
+//# sourceMappingURL=index.js.map