@kehto/runtime 0.11.0 → 0.13.0

package/dist/index.js

@@ -1,12 +1,5 @@
 // src/enforce.ts
-import { ALL_CAPABILITIES } from "@kehto/acl/capabilities";
-import { resolveCapabilitiesNub } from "@kehto/acl";
-var CLASS_CAPABILITY_ALLOWLIST = Object.freeze({
-  "class-1": new Set(ALL_CAPABILITIES),
-  "class-2": new Set(ALL_CAPABILITIES.filter(
-    (c) => c !== "relay:write" && c !== "outbox:write" && c !== "intent:write"
-  ))
-});
+import { resolveCapabilitiesNap } from "@kehto/acl";
 function createEnforceGate(config) {
   const { checkAcl, resolveIdentity, onAclCheck } = config;
   return function enforce(pubkey, capability, message) {
@@ -23,29 +16,12 @@ function createEnforceGate(config) {
     return { allowed, capability, reason };
   };
 }
-function createNubEnforceGate(config) {
+function createNapEnforceGate(config) {
   const { checkAcl, resolveIdentityByWindowId, onAclCheck } = config;
-  return function enforceNub(windowId, capability, message) {
+  return function enforceNap(windowId, capability, message) {
     const entry = resolveIdentityByWindowId(windowId);
     const dTag = entry?.dTag ?? "";
     const aggregateHash = entry?.aggregateHash ?? "";
-    const nappletClass = entry?.class ?? null;
-    if (nappletClass !== null) {
-      const allowlist = CLASS_CAPABILITY_ALLOWLIST[nappletClass];
-      if (!allowlist || !allowlist.has(capability)) {
-        const identity2 = { pubkey: "", dTag, hash: aggregateHash };
-        if (onAclCheck) {
-          onAclCheck({
-            identity: identity2,
-            capability,
-            decision: "deny",
-            message,
-            reason: "class-forbidden"
-          });
-        }
-        return { allowed: false, capability, reason: "class-forbidden" };
-      }
-    }
     const allowed = checkAcl("", dTag, aggregateHash, capability);
     const identity = { pubkey: "", dTag, hash: aggregateHash };
     const decision = allowed ? "allow" : "deny";
@@ -513,12 +489,12 @@ function routeServiceMessage(windowId, message, services, sendToNapplet) {
     handler.handleMessage(windowId, message, (msg) => sendToNapplet(windowId, msg));
     return true;
   }
-  const ifcMessage = message;
-  if (message.type === "ifc.emit" && typeof ifcMessage.topic === "string") {
-    const prefix = ifcMessage.topic.split(":")[0];
-    const ifcHandler = services[prefix];
-    if (ifcHandler) {
-      ifcHandler.handleMessage(windowId, message, (msg) => sendToNapplet(windowId, msg));
+  const incMessage = message;
+  if (message.type === "inc.emit" && typeof incMessage.topic === "string") {
+    const prefix = incMessage.topic.split(":")[0];
+    const incHandler = services[prefix];
+    if (incHandler) {
+      incHandler.handleMessage(windowId, message, (msg) => sendToNapplet(windowId, msg));
       return true;
     }
   }
@@ -600,9 +576,10 @@ function handleRelaySubscribe(context, windowId, msg, m) {
     }
     return;
   }
-  deliverFromRuntimeBackends(context, windowId, subId, subKey, filters, isShellKind, deliver);
+  const relayHint = typeof m.relay === "string" && m.relay.length > 0 ? m.relay : void 0;
+  deliverFromRuntimeBackends(context, windowId, subId, subKey, filters, isShellKind, deliver, relayHint);
 }
-function deliverFromRuntimeBackends(context, windowId, subId, subKey, filters, isShellKind, deliver) {
+function deliverFromRuntimeBackends(context, windowId, subId, subKey, filters, isShellKind, deliver, relayHint) {
   const { hooks } = context;
   const cache = hooks.cache;
   if (cache?.isAvailable() && !isShellKind) {
@@ -617,7 +594,7 @@ function deliverFromRuntimeBackends(context, windowId, subId, subKey, filters, i
     return;
   }
   if (!pool?.isAvailable() || isShellKind) return;
-  const relayUrls = pool.selectRelayTier(filters);
+  const relayUrls = relayHint ? [relayHint] : pool.selectRelayTier(filters);
   let eoseSent = false;
   const eoseFallbackTimer = setTimeout(() => {
     if (!eoseSent) {
@@ -837,39 +814,28 @@ function createIdentityHandler(context) {
   };
 }
 
-// src/ifc-handler.ts
-function createIfcRuntime(hooks, sessionRegistry) {
+// src/inc-handler.ts
+function createIncRuntime(hooks, sessionRegistry) {
   const state = {
     subscriptions: /* @__PURE__ */ new Map(),
     channels: /* @__PURE__ */ new Map(),
-    channelsByWindow: /* @__PURE__ */ new Map(),
-    domainByWindow: /* @__PURE__ */ new Map()
+    channelsByWindow: /* @__PURE__ */ new Map()
   };
   return {
     handleMessage(windowId, msg) {
-      handleIfcMessage(state, hooks, sessionRegistry, windowId, msg);
+      handleIncMessage(state, hooks, sessionRegistry, windowId, msg);
     },
     destroyWindow(windowId) {
       removeWindowChannels(state, hooks, windowId);
       removeWindowSubscriptions(state, windowId);
-      state.domainByWindow.delete(windowId);
     },
     clear() {
       state.subscriptions.clear();
       state.channels.clear();
       state.channelsByWindow.clear();
-      state.domainByWindow.clear();
     }
   };
 }
-function domainOf(type) {
-  const dot = type.indexOf(".");
-  const d = dot === -1 ? type : type.slice(0, dot);
-  return d === "inc" ? "inc" : "ifc";
-}
-function prefixFor(state, windowId, fallback) {
-  return state.domainByWindow.get(windowId) ?? fallback;
-}
 function addChannel(state, channelId, peerA, peerB) {
   state.channels.set(channelId, { channelId, peerA, peerB });
   for (const windowId of [peerA, peerB]) {
@@ -905,60 +871,55 @@ function resolveTarget(sessionRegistry, target) {
   const byPubkey = entries.find((entry) => entry.pubkey === target);
   return byPubkey?.windowId ?? null;
 }
-function handleIfcMessage(state, hooks, sessionRegistry, windowId, msg) {
+function handleIncMessage(state, hooks, sessionRegistry, windowId, msg) {
   const m = msg;
   const dotIdx = msg.type.indexOf(".");
   const action = msg.type.slice(dotIdx + 1);
-  const incomingDomain = domainOf(msg.type);
-  if (!state.domainByWindow.has(windowId)) {
-    state.domainByWindow.set(windowId, incomingDomain);
-  }
   switch (action) {
     case "emit":
-      handleEmit(state, hooks, windowId, m, incomingDomain);
+      handleEmit(state, hooks, windowId, m);
       return;
     case "subscribe":
-      handleSubscribe(state, hooks, windowId, m, incomingDomain);
+      handleSubscribe(state, hooks, windowId, m);
       return;
     case "unsubscribe":
       handleUnsubscribe(state, windowId, m);
       return;
     case "channel.open":
-      handleChannelOpen(state, hooks, sessionRegistry, windowId, m, incomingDomain);
+      handleChannelOpen(state, hooks, sessionRegistry, windowId, m);
       return;
     case "channel.emit":
-      handleChannelEmit(state, hooks, windowId, m, incomingDomain);
+      handleChannelEmit(state, hooks, windowId, m);
       return;
     case "channel.broadcast":
-      handleChannelBroadcast(state, hooks, windowId, m, incomingDomain);
+      handleChannelBroadcast(state, hooks, windowId, m);
       return;
     case "channel.list":
-      handleChannelList(state, hooks, windowId, m, incomingDomain);
+      handleChannelList(state, hooks, windowId, m);
       return;
     case "channel.close":
-      handleChannelClose(state, hooks, windowId, m, incomingDomain);
+      handleChannelClose(state, hooks, windowId, m);
       return;
     default:
       return;
   }
 }
-function handleEmit(state, hooks, windowId, m, senderDomain) {
+function handleEmit(state, hooks, windowId, m) {
   const topic = m.topic ?? "";
   if (!topic) return;
   const subscribers = state.subscriptions.get(topic);
   if (!subscribers) return;
   for (const subscriberWindowId of subscribers) {
     if (subscriberWindowId !== windowId) {
-      const prefix = prefixFor(state, subscriberWindowId, senderDomain);
-      hooks.sendToNapplet(subscriberWindowId, { type: `${prefix}.event`, topic, payload: m.payload, sender: windowId });
+      hooks.sendToNapplet(subscriberWindowId, { type: "inc.event", topic, payload: m.payload, sender: windowId });
     }
   }
 }
-function handleSubscribe(state, hooks, windowId, m, incomingDomain) {
+function handleSubscribe(state, hooks, windowId, m) {
   const id = m.id ?? "";
   const topic = m.topic ?? "";
   if (!topic) {
-    hooks.sendToNapplet(windowId, { type: `${incomingDomain}.subscribe.result`, id, error: "missing topic" });
+    hooks.sendToNapplet(windowId, { type: "inc.subscribe.result", id, error: "missing topic" });
     return;
   }
   let subscriptions = state.subscriptions.get(topic);
@@ -967,7 +928,7 @@ function handleSubscribe(state, hooks, windowId, m, incomingDomain) {
     state.subscriptions.set(topic, subscriptions);
   }
   subscriptions.add(windowId);
-  hooks.sendToNapplet(windowId, { type: `${incomingDomain}.subscribe.result`, id });
+  hooks.sendToNapplet(windowId, { type: "inc.subscribe.result", id });
 }
 function handleUnsubscribe(state, windowId, m) {
   const topic = m.topic ?? "";
@@ -977,36 +938,34 @@ function handleUnsubscribe(state, windowId, m) {
   subscriptions.delete(windowId);
   if (subscriptions.size === 0) state.subscriptions.delete(topic);
 }
-function handleChannelOpen(state, hooks, sessionRegistry, windowId, m, incomingDomain) {
+function handleChannelOpen(state, hooks, sessionRegistry, windowId, m) {
   const id = m.id ?? "";
   const peerWindow = resolveTarget(sessionRegistry, m.target ?? "");
   if (!peerWindow) {
-    hooks.sendToNapplet(windowId, { type: `${incomingDomain}.channel.open.result`, id, error: "target not found" });
+    hooks.sendToNapplet(windowId, { type: "inc.channel.open.result", id, error: "target not found" });
     return;
   }
   const channelId = hooks.crypto.randomUUID().replace(/-/g, "").slice(0, 32);
   addChannel(state, channelId, windowId, peerWindow);
-  hooks.sendToNapplet(windowId, { type: `${incomingDomain}.channel.open.result`, id, channelId, peer: peerWindow });
+  hooks.sendToNapplet(windowId, { type: "inc.channel.open.result", id, channelId, peer: peerWindow });
 }
-function handleChannelEmit(state, hooks, windowId, m, senderDomain) {
+function handleChannelEmit(state, hooks, windowId, m) {
   const peer = peerOf(state, m.channelId ?? "", windowId);
   if (peer) {
-    const prefix = prefixFor(state, peer, senderDomain);
-    hooks.sendToNapplet(peer, { type: `${prefix}.channel.event`, channelId: m.channelId ?? "", sender: windowId, payload: m.payload });
+    hooks.sendToNapplet(peer, { type: "inc.channel.event", channelId: m.channelId ?? "", sender: windowId, payload: m.payload });
   }
 }
-function handleChannelBroadcast(state, hooks, windowId, m, senderDomain) {
+function handleChannelBroadcast(state, hooks, windowId, m) {
   const channels = state.channelsByWindow.get(windowId);
   if (!channels) return;
   for (const channelId of channels) {
     const peer = peerOf(state, channelId, windowId);
     if (peer) {
-      const prefix = prefixFor(state, peer, senderDomain);
-      hooks.sendToNapplet(peer, { type: `${prefix}.channel.event`, channelId, sender: windowId, payload: m.payload });
+      hooks.sendToNapplet(peer, { type: "inc.channel.event", channelId, sender: windowId, payload: m.payload });
     }
   }
 }
-function handleChannelList(state, hooks, windowId, m, incomingDomain) {
+function handleChannelList(state, hooks, windowId, m) {
   const channels = [];
   const set = state.channelsByWindow.get(windowId);
   if (set) {
@@ -1015,15 +974,14 @@ function handleChannelList(state, hooks, windowId, m, incomingDomain) {
       if (peer) channels.push({ id: channelId, peer });
     }
   }
-  hooks.sendToNapplet(windowId, { type: `${incomingDomain}.channel.list.result`, id: m.id ?? "", channels });
+  hooks.sendToNapplet(windowId, { type: "inc.channel.list.result", id: m.id ?? "", channels });
 }
-function handleChannelClose(state, hooks, windowId, m, closerDomain) {
+function handleChannelClose(state, hooks, windowId, m) {
   const channelId = m.channelId ?? "";
   const peer = peerOf(state, channelId, windowId);
   if (!peer) return;
-  hooks.sendToNapplet(windowId, { type: `${closerDomain}.channel.closed`, channelId });
-  const peerPrefix = prefixFor(state, peer, closerDomain);
-  hooks.sendToNapplet(peer, { type: `${peerPrefix}.channel.closed`, channelId });
+  hooks.sendToNapplet(windowId, { type: "inc.channel.closed", channelId });
+  hooks.sendToNapplet(peer, { type: "inc.channel.closed", channelId });
   removeChannel(state, channelId);
 }
 function removeWindowSubscriptions(state, windowId) {
@@ -1038,17 +996,20 @@ function removeWindowChannels(state, hooks, windowId) {
   for (const channelId of Array.from(channelIds)) {
     const peer = peerOf(state, channelId, windowId);
     if (peer) {
-      const destroyeeDomain = prefixFor(state, windowId, "ifc");
-      const peerPrefix = prefixFor(state, peer, destroyeeDomain);
-      hooks.sendToNapplet(peer, { type: `${peerPrefix}.channel.closed`, channelId });
+      hooks.sendToNapplet(peer, { type: "inc.channel.closed", channelId });
     }
     removeChannel(state, channelId);
   }
 }
 
 // src/state-handler.ts
-function scopedKey(dTag, aggregateHash, userKey) {
-  return `napplet-state:${dTag}:${aggregateHash}:${userKey}`;
+var INSTANCE_MARKER = "@i/";
+function instanceSegment(windowId) {
+  return `${INSTANCE_MARKER}${windowId}:`;
+}
+function scopedKey(dTag, aggregateHash, userKey, instance = false, windowId = "") {
+  const segment = instance ? instanceSegment(windowId) : "";
+  return `napplet-state:${dTag}:${aggregateHash}:${segment}${userKey}`;
 }
 function legacyScopedKey(pubkey, dTag, aggregateHash, userKey) {
   return `napplet-state:${pubkey}:${dTag}:${aggregateHash}:${userKey}`;
@@ -1067,31 +1028,43 @@ function byteLength(str) {
   }
   return bytes;
 }
-function handleStorageNub(windowId, msg, sendToNapplet, sessionRegistry, aclState, statePersistence) {
+function handleStorageNap(windowId, msg, sendToNapplet, sessionRegistry, aclState, statePersistence) {
   const m = msg;
   const id = m.id ?? "";
   const action = msg.type.split(".")[1];
   function sendResult(payload) {
     sendToNapplet(windowId, { type: `${msg.type}.result`, id, ...payload });
   }
-  function sendErrorNub(error) {
+  function sendErrorNap(error) {
     sendToNapplet(windowId, { type: `${msg.type}.result`, id, error });
   }
   const entry = sessionRegistry.getEntryByWindowId(windowId);
   if (!entry) {
-    sendErrorNub("not registered");
+    sendErrorNap("not registered");
     return;
   }
   const { dTag, aggregateHash, pubkey } = entry;
   const prefix = `napplet-state:${dTag}:${aggregateHash}:`;
   const legacyPrefix = pubkey ? `napplet-state:${pubkey}:${dTag}:${aggregateHash}:` : "";
+  if (m.scope !== void 0 && m.scope !== "shared" && m.scope !== "instance") {
+    sendErrorNap(`invalid scope: ${String(m.scope)} (expected "shared" or "instance")`);
+    return;
+  }
+  const scope = m.scope === "instance" ? "instance" : "shared";
+  const isInstance = scope === "instance";
+  const instancePrefix = `${prefix}${instanceSegment(windowId)}`;
+  const keyFor = (userKey) => scopedKey(dTag, aggregateHash, userKey, isInstance, windowId);
   switch (action) {
     case "get": {
       const key = m.key;
       if (!key) {
-        sendErrorNub("missing key");
+        sendErrorNap("missing key");
         return;
       }
+      if (isInstance) {
+        sendResult({ value: statePersistence.get(keyFor(key)) });
+        break;
+      }
       const newKey = scopedKey(dTag, aggregateHash, key);
       let result = statePersistence.get(newKey);
       if (result === null && pubkey) {
@@ -1107,15 +1080,15 @@ function handleStorageNub(windowId, msg, sendToNapplet, sessionRegistry, aclStat
       const key = m.key;
       const value = m.value ?? "";
       if (!key) {
-        sendErrorNub("missing key");
+        sendErrorNap("missing key");
         return;
       }
       const quota = aclState.getStateQuota(pubkey ?? "", dTag, aggregateHash);
-      const sk = scopedKey(dTag, aggregateHash, key);
+      const sk = keyFor(key);
       const newWriteBytes = byteLength(sk + value);
       const existingBytes = statePersistence.calculateBytes(prefix, key);
       if (existingBytes + newWriteBytes > quota) {
-        sendErrorNub(`quota exceeded: napplet state limit is ${quota} bytes`);
+        sendErrorNap(`quota exceeded: napplet state limit is ${quota} bytes`);
         return;
       }
       const success = statePersistence.set(sk, value);
@@ -1125,29 +1098,46 @@ function handleStorageNub(windowId, msg, sendToNapplet, sessionRegistry, aclStat
     case "remove": {
       const key = m.key;
       if (!key) {
-        sendErrorNub("missing key");
+        sendErrorNap("missing key");
         return;
       }
-      statePersistence.remove(scopedKey(dTag, aggregateHash, key));
+      statePersistence.remove(keyFor(key));
       void legacyPrefix;
       sendResult({ ok: true });
       break;
     }
     case "clear": {
-      sendErrorNub("storage.clear is not in @napplet/nap/storage; action not supported");
+      sendErrorNap("storage.clear is not in @napplet/nap/storage; action not supported");
       break;
     }
     case "keys": {
+      if (isInstance) {
+        const instKeys = statePersistence.keys(instancePrefix);
+        const instanceKeySet = /* @__PURE__ */ new Set();
+        for (const k of instKeys) {
+          instanceKeySet.add(k.startsWith(instancePrefix) ? k.slice(instancePrefix.length) : k);
+        }
+        sendResult({ keys: Array.from(instanceKeySet) });
+        break;
+      }
       const newKeys = statePersistence.keys(prefix);
       const legacyKeys = legacyPrefix ? statePersistence.keys(legacyPrefix) : [];
       const userKeySet = /* @__PURE__ */ new Set();
-      for (const k of newKeys) userKeySet.add(k.startsWith(prefix) ? k.slice(prefix.length) : k);
+      for (const k of newKeys) {
+        if (!k.startsWith(prefix)) {
+          userKeySet.add(k);
+          continue;
+        }
+        const userKey = k.slice(prefix.length);
+        if (userKey.startsWith(INSTANCE_MARKER)) continue;
+        userKeySet.add(userKey);
+      }
       for (const k of legacyKeys) userKeySet.add(k.startsWith(legacyPrefix) ? k.slice(legacyPrefix.length) : k);
       sendResult({ keys: Array.from(userKeySet) });
       break;
     }
     default:
-      sendErrorNub(`unknown storage action: ${action}`);
+      sendErrorNap(`unknown storage action: ${action}`);
       break;
   }
 }
@@ -1179,7 +1169,7 @@ function createRuntimeDomainHandlers(context) {
 }
 function handleStorageMessage(context, windowId, msg) {
   const { aclState, hooks, sessionRegistry } = context;
-  handleStorageNub(windowId, msg, hooks.sendToNapplet, sessionRegistry, aclState, hooks.statePersistence);
+  handleStorageNap(windowId, msg, hooks.sendToNapplet, sessionRegistry, aclState, hooks.statePersistence);
 }
 function handleMediaMessage(context, windowId, msg) {
   const { hooks, serviceRegistry } = context;
@@ -1297,31 +1287,30 @@ function createRegisteredServices(serviceRegistry) {
   }
   return registeredServices;
 }
-function createNubEnvelopeDispatcher(handlers) {
+function createNapEnvelopeDispatcher(handlers) {
   let currentWindowId = null;
-  const nubDispatch = createDispatch();
+  const napDispatch = createDispatch();
   const adapt = (handler) => (msg) => {
     if (currentWindowId !== null) handler(currentWindowId, msg);
   };
-  nubDispatch.registerNap("relay", adapt(handlers.relay));
-  nubDispatch.registerNap("identity", adapt(handlers.identity));
-  nubDispatch.registerNap("keys", adapt(handlers.keys));
-  nubDispatch.registerNap("media", adapt(handlers.media));
-  nubDispatch.registerNap("notify", adapt(handlers.notify));
-  nubDispatch.registerNap("storage", adapt(handlers.storage));
-  nubDispatch.registerNap("ifc", adapt(handlers.ifc));
-  nubDispatch.registerNap("inc", adapt(handlers.ifc));
-  nubDispatch.registerNap("theme", adapt(handlers.theme));
-  nubDispatch.registerNap("config", adapt(handlers.config));
-  nubDispatch.registerNap("resource", adapt(handlers.resource));
-  nubDispatch.registerNap("cvm", adapt(handlers.cvm));
-  nubDispatch.registerNap("outbox", adapt(handlers.outbox));
-  nubDispatch.registerNap("upload", adapt(handlers.upload));
-  nubDispatch.registerNap("intent", adapt(handlers.intent));
+  napDispatch.registerNap("relay", adapt(handlers.relay));
+  napDispatch.registerNap("identity", adapt(handlers.identity));
+  napDispatch.registerNap("keys", adapt(handlers.keys));
+  napDispatch.registerNap("media", adapt(handlers.media));
+  napDispatch.registerNap("notify", adapt(handlers.notify));
+  napDispatch.registerNap("storage", adapt(handlers.storage));
+  napDispatch.registerNap("inc", adapt(handlers.inc));
+  napDispatch.registerNap("theme", adapt(handlers.theme));
+  napDispatch.registerNap("config", adapt(handlers.config));
+  napDispatch.registerNap("resource", adapt(handlers.resource));
+  napDispatch.registerNap("cvm", adapt(handlers.cvm));
+  napDispatch.registerNap("outbox", adapt(handlers.outbox));
+  napDispatch.registerNap("upload", adapt(handlers.upload));
+  napDispatch.registerNap("intent", adapt(handlers.intent));
   return (windowId, envelope) => {
     currentWindowId = windowId;
     try {
-      nubDispatch.dispatch(envelope);
+      napDispatch.dispatch(envelope);
     } finally {
       currentWindowId = null;
     }
@@ -1387,15 +1376,15 @@ function createFirewallGate(config) {
     return "dispatch";
   };
 }
-function createMessageHandler(hooks, enforceNub, dispatchNubEnvelope, firewallGate) {
+function createMessageHandler(hooks, enforceNap, dispatchNapEnvelope, firewallGate) {
   return (windowId, msg) => {
     if (typeof msg !== "object" || msg === null || !("type" in msg)) return;
     const envelope = msg;
     const dotIdx = envelope.type.indexOf(".");
     if (dotIdx === -1) return;
-    const caps = resolveCapabilitiesNub(envelope);
+    const caps = resolveCapabilitiesNap(envelope);
     if (caps.senderCap) {
-      const result = enforceNub(windowId, caps.senderCap, envelope);
+      const result = enforceNap(windowId, caps.senderCap, envelope);
       if (!result.allowed) {
         const id = envelope.id ?? "";
         const isStorageEnvelope = envelope.type.startsWith("storage.");
@@ -1407,7 +1396,7 @@ function createMessageHandler(hooks, enforceNub, dispatchNubEnvelope, firewallGa
     }
     const verdict = firewallGate(windowId, envelope, caps.senderCap);
     if (verdict === "drop") return;
-    dispatchNubEnvelope(windowId, envelope);
+    dispatchNapEnvelope(windowId, envelope);
   };
 }
 function createInjectedEvent(hooks, topic, payload) {
@@ -1428,7 +1417,7 @@ function createRuntimeInstance(context) {
     firewallState,
     eventBuffer,
     hooks,
-    ifcRuntime,
+    incRuntime,
     manifestCache,
     registeredServices,
     replayDetector,
@@ -1449,7 +1438,7 @@ function createRuntimeInstance(context) {
       firewallState.persist();
       replayDetector.clear();
       subscriptions.clear();
-      ifcRuntime.clear();
+      incRuntime.clear();
       eventBuffer.clear();
       registeredServices.clear();
       undeclaredServiceConsents.clear();
@@ -1476,7 +1465,7 @@ function createRuntimeInstance(context) {
           hooks.relayPool?.untrackSubscription(key);
         }
       }
-      ifcRuntime.destroyWindow(windowId);
+      incRuntime.destroyWindow(windowId);
       notifyServiceWindowDestroyed(windowId, serviceRegistry);
     },
     get sessionRegistry() {
@@ -1527,11 +1516,11 @@ function createRuntime(hooks) {
     },
     onAclCheck: hooks.onAclCheck
   });
-  const enforceNub = createNubEnforceGate({
+  const enforceNap = createNapEnforceGate({
     checkAcl: (pubkey, dTag, aggregateHash, capability) => aclState.check(pubkey, dTag, aggregateHash, capability),
     resolveIdentityByWindowId: (windowId) => {
       const entry = sessionRegistry.getEntryByWindowId(windowId);
-      return entry ? { dTag: entry.dTag, aggregateHash: entry.aggregateHash, class: entry.class } : void 0;
+      return entry ? { dTag: entry.dTag, aggregateHash: entry.aggregateHash } : void 0;
     },
     onAclCheck: hooks.onAclCheck
   });
@@ -1546,15 +1535,15 @@ function createRuntime(hooks) {
   aclState.load();
   firewallState.load();
   manifestCache.load();
-  const ifcRuntime = createIfcRuntime(hooks, sessionRegistry);
+  const incRuntime = createIncRuntime(hooks, sessionRegistry);
   const domainHandlers = createRuntimeDomainHandlers({ hooks, serviceRegistry, sessionRegistry, aclState });
-  const dispatchNubEnvelope = createNubEnvelopeDispatcher({
+  const dispatchNapEnvelope = createNapEnvelopeDispatcher({
     relay: createRelayHandler({ hooks, serviceRegistry, subscriptions, eventBuffer, replayDetector }),
     identity: createIdentityHandler({ hooks, serviceRegistry }),
-    ifc: ifcRuntime.handleMessage,
+    inc: incRuntime.handleMessage,
     ...domainHandlers
   });
-  const handleMessage = createMessageHandler(hooks, enforceNub, dispatchNubEnvelope, firewallGate);
+  const handleMessage = createMessageHandler(hooks, enforceNap, dispatchNapEnvelope, firewallGate);
   return createRuntimeInstance({
     hooks,
     serviceRegistry,
@@ -1562,7 +1551,7 @@ function createRuntime(hooks) {
     replayDetector,
     subscriptions,
     eventBuffer,
-    ifcRuntime,
+    incRuntime,
     sessionRegistry,
     aclState,
     firewallState,
@@ -1573,9 +1562,9 @@ function createRuntime(hooks) {
 }
 
 // src/index.ts
-import { ALL_CAPABILITIES as ALL_CAPABILITIES2 } from "@kehto/acl/capabilities";
+import { ALL_CAPABILITIES } from "@kehto/acl/capabilities";
 export {
-  ALL_CAPABILITIES2 as ALL_CAPABILITIES,
+  ALL_CAPABILITIES,
   RING_BUFFER_SIZE,
   cleanupNappState,
   createAclState,
@@ -1583,17 +1572,17 @@ export {
   createEventBuffer,
   createFirewallState,
   createManifestCache,
+  createNapEnforceGate,
   createNappKeyRegistry,
-  createNubEnforceGate,
   createReplayDetector,
   createRuntime,
   createSessionRegistry,
   formatDenialReason,
-  handleStorageNub,
+  handleStorageNap,
   matchesAnyFilter,
   matchesFilter,
   notifyServiceWindowDestroyed,
-  resolveCapabilitiesNub,
+  resolveCapabilitiesNap,
   routeServiceMessage
 };
 //# sourceMappingURL=index.js.map