@kehto/shell 0.26.0 → 0.27.0

package/README.md

@@ -14,8 +14,10 @@ pnpm add @kehto/shell
 
 ## Published Napplet Compatibility
 
-`@kehto/shell` publishes against `@napplet/core` and `@napplet/nap`
-`>=0.32.0 <0.33.0`. The installed core 0.32.0 / nap 0.32.0 contracts follow
+Peers admit `@napplet/core` `>=0.32.0 <0.38.0` and `@napplet/nap`
+`>=0.32.0 <0.37.0`, so the nap 0.35.x line that ships the `llm` subpath (and the
+core 0.36.x line nap 0.35.1 requires) installs without peer conflicts; development
+and tests stay on the baseline 0.32.0 line. The installed core 0.32.0 / nap 0.32.0 contracts follow
 NAP-INTENT authority `5ac0490461ca6fec2f0d2e45b4835cf9bc08de24`, napplet/web#199
 source `3037200c932488f14f7f369b8583c39c9c16510a` / merge
 `b3f0007867eac109fa4917fac9c285d3b7cc6155`, and Version Packages #198 release
@@ -23,9 +25,9 @@ source `dc1d24153c759152b6ba31a6ec9bea967798f2df`.
 
 ## Overview
 
-`@kehto/shell` is the browser-specific integration layer for kehto. It wraps `@kehto/runtime` with the window/postMessage transport, localStorage persistence hooks, an audio manager, and the five canonical per-domain proxies defined by NIP-5D.
+`@kehto/shell` is the browser-specific integration layer for kehto. It wraps `@kehto/runtime` with the NIP-5D port-bound transport (one window-level `napplet.hello`, then a dedicated `MessagePort`), localStorage persistence hooks, an audio manager, and the five canonical per-domain proxies defined by NIP-5D.
 
-The primary entry point is `createShellBridge()` — it owns the postMessage listener, the NAP-SHELL `shell.ready` / `shell.init` handshake, manifest verification, and every dispatch back into the runtime engine.
+The primary entry point is `createShellBridge()` — it owns the `napplet.hello` listener and port binding, the NAP-SHELL `shell.ready` / `shell.init` handshake, manifest verification, and every dispatch back into the runtime engine.
 
 ACL persistence uses the browser's `localStorage` key `napplet:acl`. A failed
 write is intentionally reported through `bridge.runtime.aclState.persist()` or
@@ -101,6 +103,38 @@ remain bounded compatibility adapters and warn once per iframe with
 `KEHTO_COMPAT_INTENT_OBJECT_INVOKE`. Their removal conditions are tracked in
 [compatibility](https://github.com/kehto/web/blob/main/docs/compatibility.md).
 
+### NIP-5D port-bound transport
+
+NIP-5D ([nostr-protocol/nips#2303 at `51ef0cd`](https://github.com/nostr-protocol/nips/blob/51ef0cd33a5694784306f3260d90b1872545fdee/5D.md))
+binds napplet identity to a `MessagePort`, not the iframe `Window`. A `Window`
+survives same-frame navigation, but the port lives only in the verified document:
+
+- The injected prelude opens a `MessageChannel` before napplet scripts run,
+  keeps one port private, and sends the other once in a window-level
+  `{ type: 'napplet.hello' }` (`NAPPLET_HELLO`). Every NAP message then travels
+  over that port in both directions.
+- `ShellBridge.handleMessage` accepts the hello only from the `contentWindow` of
+  an iframe registered in `originRegistry`, carrying exactly one port. It binds
+  the registered `(dTag, aggregateHash)` to the port. Shell senders use
+  `originRegistry.postToNapplet(windowId, message)` or `getNappletTarget(windowId)`,
+  never `iframeWindow.postMessage`.
+- A second hello, any other window-level message, a hello without exactly one
+  port, a second iframe `load`, or the port closing revokes the napplet. The
+  bridge closes the port, revokes its sessions, subscriptions and environment,
+  and calls `ShellAdapter.onNappletRevoked({ windowId, reason, detail })`. The
+  host must remove that frame. `ShellBridge.revokeNapplet(windowId)` revokes on
+  demand.
+- `ShellBridge.observeFrame(frame, windowId)` watches for the second load. Call
+  it after the frame is in the DOM and before assigning `srcdoc`.
+- `originRegistry.register()` throws for a `Window` that already handed over (or
+  lost) its port. Create a fresh iframe for every reload or navigation.
+- `ShellAdapter.onNappletMessage(windowId, message)` observes each port envelope
+  before dispatch, for logging or readiness tracking.
+
+Napplets hosted with this prelude must not also import `@napplet/shim`, because
+the shim sends a second hello. The retired window-level transport is recorded as
+`NIP5D_WINDOW_TRANSPORT_RETIRED` in the [compatibility register](https://github.com/kehto/web/blob/main/docs/compatibility.md).
+
 ## Quick Start
 
 ```ts
@@ -123,13 +157,16 @@ bridge.runtime.registerService(
 ## Public API
 
 ### Bridge factory
-- `createShellBridge` — primary entry point; returns a `ShellBridge` (exposed `runtime`, `shell.ready`, lifecycle hooks)
+- `createShellBridge` — primary entry point; returns a `ShellBridge` (exposed `runtime`, `shell.ready`, lifecycle hooks, `observeFrame`, `revokeNapplet`)
+- `NAPPLET_HELLO` — the NIP-5D port handoff message type
 - `ShellBridge` — interface type for the returned bridge
 
 ### Hooks adapter
 - `adaptHooks` — convert a `ShellAdapter` + `BrowserDeps` into the canonical `RuntimeAdapter` hook bag consumed by `@kehto/runtime`
 
 ### Diagnostics
+- `ShellAdapter.onNappletRevoked?(revocation)` — called once when the bridge revokes a NIP-5D binding (`NappletRevocation`: `{ windowId, reason, detail }`, `reason` one of `NappletRevocationReason`). The host must remove the frame.
+- `ShellAdapter.onNappletMessage?(windowId, message)` — observe-only; called for each NAP envelope received on a bound port before dispatch.
 - `ShellAdapter.onUnroutedMessage?(info)` — optional observe-only hook fired when `ShellBridge.handleMessage` drops an incoming postMessage it can't route to a registered napplet window. `info` is an `UnroutedMessageInfo` (`{ type?, origin, reason }`) where `reason` is `'no-source-window'` or `'unregistered-window'`. The message is still dropped — this exists so otherwise-silent drops (e.g. an intent/`srcdoc` iframe whose `contentWindow` was never registered in `originRegistry`, or was swapped by a reload) are diagnosable instead of vanishing. Host can `console.warn` inside its own hook; the bridge adds no console output and swallows hook errors so routing is never broken.
 
 ```ts
@@ -218,14 +255,15 @@ payload.
 ### Session / origin registry
 - `sessionRegistry` — canonical windowId ↔ verified-napplet registry singleton
 - `nappKeyRegistry` — deprecated alias for `sessionRegistry`
-- `originRegistry` — origin-to-windowId map used by proxies and bridge broadcasts
+- `originRegistry` — iframe `Window` → windowId/identity map; also holds each window's bound NIP-5D port (`bindPort`, `getPort`, `postToNapplet`, `getNappletTarget`, `isSpent`)
+- `NappletMessageTarget` — port-backed outbound target passed to `RelayPoolHooks.openScopedRelay`
 - `PendingUpdate` — type for pending aggregate-hash change prompts
 
 Environment snapshots belong to one source registration. To retire a window,
 call `bridge.runtime.destroyWindow(windowId)`,
 `bridge.runtime.sessionRegistry.unregister(windowId)`, and
 `originRegistry.unregister(windowId)`. When registering a replacement under the
-same window ID, provide its snapshot with `originRegistry.setEnvironment()` or
+same window ID (always a fresh iframe — a spent `Window` cannot be re-registered), provide its snapshot with `originRegistry.setEnvironment()` or
 let the bridge call `resolveShellEnvironment()` for current host defaults. A
 retired registration's cached domains and service names are discarded even when
 the runtime session was already removed. This applies before any domain dispatch,
@@ -303,11 +341,11 @@ for outer URL encoding, review, routing, and verified launcher behavior.
 
 ## GAMEPAD integration
 
-This non-normative guidance defers to the living [NAP-GAMEPAD](https://github.com/napplet/naps/pull/108). Services export `createGamepadService` and `browserGamepadOptions`; shell exports `denyNappletControllerAccess`. Paja and the playground register one host reader and deny native gamepad/HID/USB paths before frame execution. Source-bound subscriptions receive immediate full snapshots; only the visible host's input owner gets live controls. Focus loss supplies neutral controls and timestamp zero; unsubscribe, window destruction, and service removal release polling. Non-browser or denied native readers report the proposal's unavailable reasons. See [Controller input](https://github.com/kehto/web/blob/main/docs/gamepad.md).
+This non-normative guidance defers to the living [NAP-GAMEPAD](https://github.com/napplet/naps/pull/108). Services export `createGamepadService` and `browserGamepadOptions`; shell exports `denyNappletControllerAccess`. Paja registers one host reader and deny native gamepad/HID/USB paths before frame execution. Source-bound subscriptions receive immediate full snapshots; only the visible host's input owner gets live controls. Focus loss supplies neutral controls and timestamp zero; unsubscribe, window destruction, and service removal release polling. Non-browser or denied native readers report the proposal's unavailable reasons. See [Controller input](https://github.com/kehto/web/blob/main/docs/gamepad.md).
 
 ## LLM integration
 
-This non-normative guidance defers to the living [NAP-LLM](https://github.com/napplet/naps/pull/134) (checked at `3e10939`). Services export `createLlmService`, `LlmServiceError`, the provider mappers and `LLM_PROVIDER_PRESETS`; shell exports `getShellDomainState` and the `LlmHooks` adapter field; acl exports `llm:generate`. The runtime routes `llm.*` to one registered service and answers every sanctioned request with exactly one `llm.<op>.result`, shaping missing-service and ACL failures as `{ code: 'unsupported' }`. Hosts implement `LlmConnectionHost`; the service enforces schema, handle ownership, consent before submission, duplicate ids, cancellation and deadline races, ordered deltas and safe errors. Advertisement stays binary on the wire while hosts report a third `unconfigured` state until the user adds a connection. See [Language models](https://github.com/kehto/web/blob/main/docs/llm.md).
+This non-normative guidance defers to the living [NAP-LLM](https://github.com/napplet/naps/pull/134) (checked at `3e10939`). Services export `createLlmService`, `LlmServiceError`, the provider mappers and `LLM_PROVIDER_PRESETS`; shell exports `getShellDomainState` and the `LlmHooks` adapter field; acl exports `llm:generate`. The runtime routes `llm.*` to one registered service and answers every sanctioned request with exactly one `llm.<op>.result`, shaping missing-service and ACL failures as `{ code: 'unsupported' }`. Hosts implement `LlmConnectionHost`; the service enforces schema, handle ownership, a per-window live-handle bound (`maxHandlesPerWindow`), consent before submission, duplicate ids, cancellation and deadline races, ordered deltas and safe errors, and passes `select`/`authorize` a `{ signal }` that withdraws stale prompts. `createHttpLlmProvider({ stream: true })` streams provider output into `llm.delta`. Advertisement stays binary on the wire while hosts report a third `unconfigured` state until the user adds a connection. See [Language models](https://github.com/kehto/web/blob/main/docs/llm.md).
 
 ## UUID support on HTTP origins
 

package/dist/index.d.ts

@@ -6,14 +6,30 @@ import { Theme } from '@napplet/nap/theme/types';
 import { ResourceBytesItem, ResourceBytesRequest as ResourceBytesRequest$1, ResourceInfo } from '@napplet/nap/resource/types';
 export { ResourceInfo } from '@napplet/nap/resource/types';
 
+/**
+ * Minimal outbound target for one napplet. NIP-5D carries every NAP message
+ * over the port bound by `napplet.hello`, so this never wraps the iframe
+ * `Window`.
+ *
+ * @example
+ * ```ts
+ * originRegistry.getNappletTarget('napp-1')?.postMessage({ type: 'relay.eose', subId });
+ * ```
+ */
+interface NappletMessageTarget {
+    /** Post one NAP envelope over the bound port. Dropped when no port is bound. */
+    postMessage(message: unknown): void;
+}
 /** NIP-5D identity metadata associated with a registered iframe window. */
 interface OriginIdentity {
     readonly dTag: string;
     readonly aggregateHash: string;
 }
 /**
- * Bidirectional registry mapping Window references to windowId strings.
- * Optionally stores NIP-5D identity metadata (dTag and aggregateHash) per window.
+ * Registry mapping each shell-created iframe Window to its windowId, verified
+ * NIP-5D identity, and the `MessagePort` bound by its single `napplet.hello`.
+ * The Window is only used to authenticate the hello; all NAP traffic uses the
+ * bound port (NIP-5D, nostr-protocol/nips#2303).
  *
  * @example
  * ```ts
@@ -26,6 +42,11 @@ interface OriginIdentity {
 interface OriginRegistry {
     register(win: Window, windowId: string, identity?: OriginIdentity): void;
     unregister(windowId: string): void;
+    bindPort(windowId: string, port: MessagePort): boolean;
+    getPort(windowId: string): MessagePort | undefined;
+    postToNapplet(windowId: string, message: unknown): boolean;
+    getNappletTarget(windowId: string): NappletMessageTarget | null;
+    isSpent(win: Window): boolean;
     getWindowId(win: Window): string | undefined;
     getIframeWindow(windowId: string): Window | null;
     getAllWindowIds(): string[];
@@ -73,7 +94,7 @@ interface RelayPoolHooks {
     /** Untrack and clean up a subscription. */
     untrackSubscription(subKey: string): void;
     /** Open a scoped relay connection (NIP-29 groups). */
-    openScopedRelay(windowId: string, relayUrl: string, subId: string, filters: NostrFilter[], sourceWindow: Window): void;
+    openScopedRelay(windowId: string, relayUrl: string, subId: string, filters: NostrFilter[], target: NappletMessageTarget): void;
     /** Close a scoped relay connection. */
     closeScopedRelay(windowId: string): void;
     /**
@@ -348,6 +369,33 @@ interface UnroutedMessageInfo {
      */
     reason: 'no-source-window' | 'unregistered-window';
 }
+/**
+ * Why a NIP-5D napplet binding was revoked.
+ * - `window-message` — a window-level message other than the one `napplet.hello`.
+ * - `second-hello` — a second `napplet.hello` from the same iframe.
+ * - `invalid-hello` — a `napplet.hello` without exactly one transferred port.
+ * - `second-load` — the iframe loaded a second document (navigation or reload).
+ * - `port-closed` — the bound port closed or failed to deserialize a message.
+ * - `host` — the host revoked the binding itself.
+ */
+type NappletRevocationReason = 'window-message' | 'second-hello' | 'invalid-hello' | 'second-load' | 'port-closed' | 'host';
+/**
+ * Passed to {@link ShellAdapter.onNappletRevoked} after the shell closed the
+ * port and revoked the identity binding, sessions and grants of one frame.
+ *
+ * @example
+ * ```ts
+ * hooks.onNappletRevoked = ({ windowId }) => frames.get(windowId)?.remove();
+ * ```
+ */
+interface NappletRevocation {
+    /** The revoked window. Its identity can never be re-bound to the same iframe. */
+    readonly windowId: string;
+    /** What the shell observed. */
+    readonly reason: NappletRevocationReason;
+    /** Human-readable detail for diagnostics. Never includes message payloads. */
+    readonly detail: string;
+}
 /**
  * Static capability set sent to napplet iframes through the shell.ready /
  * shell.init handshake. Optional runtime domain presence is injected before
@@ -461,6 +509,24 @@ interface ShellAdapter {
      * (the FEED-02 / hyprgate#21 class of "a napplet's messages vanish" bug).
      */
     onUnroutedMessage?: (info: UnroutedMessageInfo) => void;
+    /**
+     * Called once when the shell revokes a NIP-5D napplet binding: a second
+     * `napplet.hello`, any other window-level message, an invalid hello, a
+     * second iframe `load` (see `ShellBridge.observeFrame`), the port closing,
+     * or `ShellBridge.revokeNapplet`. The shell has already closed the port and
+     * revoked the identity binding, sessions and grants. NIP-5D requires the
+     * host to remove the iframe here; it MAY create a fresh iframe from the
+     * verified bytes but MUST NOT reuse this one.
+     */
+    onNappletRevoked?: (revocation: NappletRevocation) => void;
+    /**
+     * Observe-only: called with each NAP envelope received on a napplet's bound
+     * NIP-5D port, before the shell dispatches it. NIP-5D moves NAP traffic off
+     * window-level `message` events, so hosts that logged or tracked readiness
+     * from those events use this hook instead. It cannot change or drop the
+     * message; host hook errors are swallowed.
+     */
+    onNappletMessage?: (windowId: string, message: NappletMessage) => void;
     /** Called when aggregate hash verification fails (computed != declared). */
     onHashMismatch?: (dTag: string, claimed: string, computed: string) => void;
     /**
@@ -497,14 +563,36 @@ interface ShellAdapter {
     getConfigOverrides?(): RuntimeConfigOverrides;
 }
 
+/**
+ * NIP-5D port-bound transport for ShellBridge (nostr-protocol/nips#2303 at
+ * 51ef0cd33a5694784306f3260d90b1872545fdee, packaged by napplet/web#302).
+ *
+ * A napplet's injected bootstrap transfers one MessagePort in a single
+ * window-level `napplet.hello`. The shell binds the registered identity to
+ * that port, dispatches NAP only from it, and revokes the binding on any
+ * evidence that the verified document was replaced.
+ *
+ * @module
+ */
+
+/** The NIP-5D port handoff message type (nostr-protocol/nips#2303). */
+declare const NAPPLET_HELLO = "napplet.hello";
+
 /**
  * Shell-side message bridge that handles NIP-5D communication with napplet iframes.
  *
- * The bridge acts as a browser adapter: it receives raw MessageEvents from
- * window.addEventListener('message', ...), extracts the source Window, resolves
- * it to a windowId via originRegistry, and delegates NIP-5D envelope messages
- * to the runtime engine. The shell.ready/shell.init capability handshake is
- * handled locally within the bridge and never forwarded to the runtime.
+ * NIP-5D binds napplet identity to a `MessagePort`, not to the iframe Window:
+ * the injected bootstrap transfers one port to the shell in a single
+ * window-level `napplet.hello`. The bridge accepts that hello only from the
+ * `contentWindow` of a registered iframe carrying exactly one port, binds the
+ * frame's verified `(dTag, aggregateHash)` to the port, and then processes NAP
+ * envelopes only from that port and replies only over it. A second hello, any
+ * other window-level message, an invalid hello, a second iframe `load`
+ * ({@link ShellBridge.observeFrame}) or the port closing revokes the binding,
+ * its sessions and grants, and asks the host to remove the frame through
+ * `ShellAdapter.onNappletRevoked`. The shell.ready/shell.init capability
+ * handshake is handled locally within the bridge and never forwarded to the
+ * runtime.
  *
  * @example
  * ```ts
@@ -516,15 +604,19 @@ interface ShellAdapter {
  */
 interface ShellBridge {
     /**
-     * Handle an incoming postMessage from a napplet iframe.
+     * Handle a window-level message from a napplet iframe.
      *
-     * Only NIP-5D envelope objects (plain objects with a `.type` string) are
-     * accepted. NIP-01 arrays and all other message shapes are silently dropped
-     * (clean break — no legacy array fallback).
+     * The only window-level message a napplet may send is its single
+     * `napplet.hello` carrying exactly one `MessagePort`. The bridge binds that
+     * port and receives every later NAP envelope from it. Any other window-level
+     * message from a registered iframe, a second hello, or a hello without
+     * exactly one port revokes the frame. Messages from unregistered sources are
+     * dropped.
      *
-     * shell.ready messages are handled locally: the bridge responds with shell.init
-     * containing the capability set and registered service list. All other envelopes
-     * are delegated to the runtime's NAP domain dispatch.
+     * On the bound port, only NIP-5D envelope objects (plain objects with a
+     * `.type` string) are accepted. shell.ready is handled locally (the bridge
+     * answers with shell.init over the port); all other envelopes are delegated
+     * to the runtime's NAP domain dispatch.
      *
      * @param event - The raw MessageEvent from window.addEventListener('message', ...)
      * @example
@@ -605,6 +697,36 @@ interface ShellBridge {
      * @param pubkey - Current user's hex pubkey, or empty string when signed out.
      */
     publishIdentityChanged(pubkey: string): void;
+    /**
+     * Watch a napplet iframe for a second `load`, which NIP-5D treats as
+     * evidence that the verified document was replaced. Call after the frame is
+     * in the DOM and before assigning its `srcdoc`/`src`.
+     *
+     * @param frame - The shell-created napplet iframe
+     * @param windowId - The windowId registered for this frame
+     * @returns A function that stops watching
+     * @example
+     * ```ts
+     * document.body.append(frame);
+     * originRegistry.register(frame.contentWindow!, windowId, identity);
+     * const stop = bridge.observeFrame(frame, windowId);
+     * frame.srcdoc = verifiedSrcdoc;
+     * ```
+     */
+    observeFrame(frame: Pick<HTMLIFrameElement, 'addEventListener' | 'removeEventListener'>, windowId: string): () => void;
+    /**
+     * Revoke one napplet binding: close its port, unregister it, destroy its
+     * sessions and subscriptions, and call `ShellAdapter.onNappletRevoked` so
+     * the host removes the frame. No-op for unknown windows.
+     *
+     * @param windowId - The window to revoke
+     * @param reason - Why the binding is revoked (defaults to `host`)
+     * @example
+     * ```ts
+     * bridge.revokeNapplet(windowId);
+     * ```
+     */
+    revokeNapplet(windowId: string, reason?: NappletRevocationReason): void;
     /**
      * Access the underlying runtime instance for advanced use cases.
      * Provides direct access to the runtime's sessionRegistry, aclState,
@@ -612,6 +734,31 @@ interface ShellBridge {
      */
     readonly runtime: Runtime;
 }
+/**
+ * Create a ShellBridge instance with dependency injection via hooks.
+ *
+ * Internally creates a Runtime from @kehto/runtime and adapts the
+ * browser-oriented ShellAdapter into environment-agnostic RuntimeAdapter.
+ *
+ * @param hooks - Host application provides relay pool, auth, config, etc.
+ * @returns A ShellBridge instance ready to handle napplet messages
+ * @example
+ * ```ts
+ * import { createShellBridge, type ShellAdapter } from '@kehto/shell';
+ *
+ * const hooks: ShellAdapter = {
+ *   relayPool: myRelayPoolHooks,
+ *   relayConfig: myRelayConfigHooks,
+ *   windowManager: myWindowManagerHooks,
+ *   auth: myAuthHooks,
+ *   config: myConfigHooks,
+ *   hotkeys: myHotkeyHooks,
+ *   workerRelay: myWorkerRelayHooks,
+ *   crypto: myCryptoHooks,
+ * };
+ * const bridge = createShellBridge(hooks);
+ * ```
+ */
 declare function createShellBridge(hooks: ShellAdapter): ShellBridge;
 
 /**
@@ -1054,11 +1201,12 @@ declare function getShellDomainState(hooks: ShellAdapter, domain: string): Shell
  * Minimal origin-registry contract used by per-domain proxies.
  *
  * Accepts the `@kehto/shell` singleton `originRegistry` as well as any test
- * double with a matching `getIframeWindow` method.
+ * double with a matching `postToNapplet` method. NIP-5D carries every NAP
+ * message over the port bound by `napplet.hello`, never the iframe Window.
  */
 interface ProxyOriginRegistry {
-    /** Resolve a registered napplet windowId to its iframe Window, or null. */
-    getIframeWindow(windowId: string): Window | null;
+    /** Send one envelope over the window's bound NIP-5D port; `false` when unbound. */
+    postToNapplet(windowId: string, message: unknown): boolean;
 }
 /**
  * Dependencies for `createIdentityProxy`.
@@ -1074,7 +1222,7 @@ interface ProxyOriginRegistry {
 interface IdentityProxyDeps {
     /** The runtime engine that owns identity.* dispatch (Plan 12-03). */
     runtime: Runtime;
-    /** Origin registry for resolving windowId → iframe Window. */
+    /** Origin registry that delivers envelopes over each window's bound port. */
     originRegistry: ProxyOriginRegistry;
 }
 /**
@@ -1616,4 +1764,4 @@ type ResourceInbound = ResourceInfoRequest | ResourceBytesRequest | ResourceByte
  */
 type ResourceOutbound = ResourceInfoResult | ResourceInfoError | ResourceBytesResult | ResourceBytesError | ResourceBytesManyResult | ResourceBytesManyError;
 
-export { type AclCheckEvent, type AclEntry, type AclStore, type AudioManager, type AudioSource, type AuthHooks, type BleHooks, type BrowserDeps, type CapabilityHooks, type CommonHooks, type ConfigHooks, type CryptoHooks, type DmHooks, type HotkeyHooks, type IdentityProxy, type IdentityProxyDeps, type IntentHooks, type KeysProxy, type KeysProxyDeps, type LinkHooks, type ListsHooks, type LlmHooks, type ManifestCache, type ManifestCacheEntry, type MediaProxy, type MediaProxyDeps, type NappletCspDirective, type NappletCspDirectives, type NappletCspOptions, type NappletNamespacePreludeOptions, type NappletSrcdocOptions, type NormalizedIntentUri, type NotifyProxy, type NotifyProxyDeps, type OriginIdentity, type OriginRegistry, type ProxyOriginRegistry, type RelayConfigHooks, type RelayPoolHooks, type RelayPoolLike, type ResourceBytesError, type ResourceBytesManyError, type ResourceBytesManyItem, type ResourceBytesManyRequest, type ResourceBytesManyResult, type ResourceBytesRequest, type ResourceBytesResult, type ResourceCancelRequest, type ResourceErrorCode, type ResourceInbound, type ResourceInfoError, type ResourceInfoRequest, type ResourceInfoResult, type ResourceOutbound, type ResourceRequestId, type SerialHooks, type SessionRegistry, type ShellAdapter, type ShellBridge, type ShellCapabilities, type ShellDomainState, type ShellEnvironment, type ThemeProxy, type ThemeProxyDeps, type UnroutedMessageInfo, type UploadBackendLike, type UploadHooks, type WebrtcHooks, type WindowManagerHooks, type WorkerRelayHooks, type WorkerRelayLike, adaptHooks, audioManager, buildNappletCsp, buildShellCapabilities, createIdentityProxy, createKeysProxy, createMediaProxy, createNotifyProxy, createShellBridge, createThemeProxy, denyNappletControllerAccess, getShellDomainState, injectNappletCsp, injectNappletNamespacePrelude, manifestCache, nappKeyRegistry, normalizeIntentUri, originRegistry, prepareNappletSrcdoc, renderNappletCspMeta, renderNappletNamespacePrelude, resolveShellEnvironment, sessionRegistry };
+export { type AclCheckEvent, type AclEntry, type AclStore, type AudioManager, type AudioSource, type AuthHooks, type BleHooks, type BrowserDeps, type CapabilityHooks, type CommonHooks, type ConfigHooks, type CryptoHooks, type DmHooks, type HotkeyHooks, type IdentityProxy, type IdentityProxyDeps, type IntentHooks, type KeysProxy, type KeysProxyDeps, type LinkHooks, type ListsHooks, type LlmHooks, type ManifestCache, type ManifestCacheEntry, type MediaProxy, type MediaProxyDeps, NAPPLET_HELLO, type NappletCspDirective, type NappletCspDirectives, type NappletCspOptions, type NappletMessageTarget, type NappletNamespacePreludeOptions, type NappletRevocation, type NappletRevocationReason, type NappletSrcdocOptions, type NormalizedIntentUri, type NotifyProxy, type NotifyProxyDeps, type OriginIdentity, type OriginRegistry, type ProxyOriginRegistry, type RelayConfigHooks, type RelayPoolHooks, type RelayPoolLike, type ResourceBytesError, type ResourceBytesManyError, type ResourceBytesManyItem, type ResourceBytesManyRequest, type ResourceBytesManyResult, type ResourceBytesRequest, type ResourceBytesResult, type ResourceCancelRequest, type ResourceErrorCode, type ResourceInbound, type ResourceInfoError, type ResourceInfoRequest, type ResourceInfoResult, type ResourceOutbound, type ResourceRequestId, type SerialHooks, type SessionRegistry, type ShellAdapter, type ShellBridge, type ShellCapabilities, type ShellDomainState, type ShellEnvironment, type ThemeProxy, type ThemeProxyDeps, type UnroutedMessageInfo, type UploadBackendLike, type UploadHooks, type WebrtcHooks, type WindowManagerHooks, type WorkerRelayHooks, type WorkerRelayLike, adaptHooks, audioManager, buildNappletCsp, buildShellCapabilities, createIdentityProxy, createKeysProxy, createMediaProxy, createNotifyProxy, createShellBridge, createThemeProxy, denyNappletControllerAccess, getShellDomainState, injectNappletCsp, injectNappletNamespacePrelude, manifestCache, nappKeyRegistry, normalizeIntentUri, originRegistry, prepareNappletSrcdoc, renderNappletCspMeta, renderNappletNamespacePrelude, resolveShellEnvironment, sessionRegistry };