@kehto/shell 0.21.1 → 0.21.3

package/README.md

@@ -85,9 +85,10 @@ unsupported fields and caller-supplied sender data, and resolves only
 parent-originated correlated results.
 
 Successful results include `handled`, `handler`, `windowId`, and `convention`
-after target dispatch completes. There is no `intent.deliver` or `onDelivery`;
-selected targets consume their convention through the ordinary
-runtime-attested INC binding.
+after target dispatch completes. Target delivery now follows NAP-INTENT at
+`25b29ee49e5bff8ebfe031f4b76dce98705c8b7e`: one `intent.deliver` envelope
+feeds the buffered `onDelivery` binding described below. Broader invocation and
+result changes from that newer spec remain deferred.
 
 Phase 105 completed released `@napplet/*` package adoption and persistent live
 Paja/playground catalogs and target controllers. The Phase 104 Paja simulator
@@ -211,3 +212,27 @@ Generated API module: `docs/api/modules/_kehto_shell.html` (run `pnpm docs:api`)
 ## License
 
 MIT
+
+## NIP-5D event compatibility
+
+Current manifests use a direct artifact `x` hash, plain-text `content`, independent
+`z`/`i` routing declarations, and required `R` / optional `O` domains. Kehto also
+accepts legacy aggregate events through an isolated compatibility adapter.
+Existing `aggregateHash` host/cache/ACL fields carry the verified artifact hash
+for current events; legacy identities keep their original aggregate. Both paths
+verify signatures and bytes before runtime injection and `srcdoc` execution.
+For the schema and removal boundary, see [event migration](https://kehto.github.io/web/docs/migrations/NIP-5D-EVENT-SCHEMA.html).
+
+### Intent delivery
+
+The injected `window.napplet.intent.onDelivery(handler)` returns a closeable
+subscription and drains buffered parent deliveries in order. Register it to
+receive `{ sender, archetype, action, convention, payload? }`; INC is not required.
+Its receiver is installed before `shell.ready` and survives namespace reassignment.
+A throwing listener does not prevent delivery to other listeners.
+
+When no canonical listener is registered, matching legacy INC listeners can
+consume the delivery locally. This emits `KEHTO_COMPAT_INTENT_INC` once per
+iframe; a delivery is never replayed to both APIs. See [compatibility tracking](https://github.com/kehto/web/blob/main/docs/compatibility.md).
+This aligns delivery with NAP-INTENT at `25b29ee`; broader invocation/result
+changes and the packaged SDK upgrade remain deferred.

package/dist/index.js

@@ -389,7 +389,7 @@ var originRegistry = {
    */
   getIdentity(win) {
     const entry = registry.get(win);
-    if (!entry?.dTag || !entry?.aggregateHash) return void 0;
+    if (typeof entry?.dTag !== "string" || !entry?.aggregateHash) return void 0;
     return { dTag: entry.dTag, aggregateHash: entry.aggregateHash };
   },
   /** Store the immutable environment captured for this exact frame registration. */
@@ -1691,7 +1691,13 @@ function nappletNamespacePrelude(domains) {
           fire({ type: "inc.subscribe", id: subscriptionId, topic: stableTopic });
         }
         state.handlers.add(callback);
+        const offLegacy = intentDelivery?.onLegacy(stableTopic, (delivery) => callback({
+          topic: delivery.convention,
+          sender: delivery.sender,
+          ...Object.prototype.hasOwnProperty.call(delivery, "payload") ? { payload: delivery.payload } : {}
+        }));
         return subscriptionHandle(() => {
+          offLegacy?.();
           const current = topicStates.get(stableTopic);
           if (!current) return;
           current.handlers.delete(callback);
@@ -2253,6 +2259,69 @@ function nappletNamespacePrelude(domains) {
       }
     };
   }
+  function makeIntentDelivery() {
+    const handlers = /* @__PURE__ */ new Set();
+    const legacy = /* @__PURE__ */ new Map();
+    const pending = [];
+    let draining = false;
+    let warned = false;
+    function drain() {
+      if (draining) return;
+      draining = true;
+      try {
+        while (pending.length > 0) {
+          const index = handlers.size > 0 ? 0 : pending.findIndex((delivery2) => [...legacy.values()].includes(delivery2.convention));
+          if (index < 0) break;
+          const [delivery] = pending.splice(index, 1);
+          const canonical = handlers.size > 0;
+          const recipients = canonical ? [...handlers] : [...legacy.entries()].filter(([, topic]) => topic === delivery.convention).map(([handler]) => handler);
+          if (!canonical && !warned) {
+            warned = true;
+            console.warn("[KEHTO_COMPAT_INTENT_INC] Intent delivered to a legacy INC listener. Migrate to window.napplet.intent.onDelivery. See docs/compatibility.md.");
+          }
+          for (const handler of recipients) {
+            try {
+              handler(delivery);
+            } catch (error) {
+              console.error("Intent delivery handler failed", error);
+            }
+          }
+        }
+      } finally {
+        draining = false;
+      }
+    }
+    listen((event) => {
+      if (!isParentMessage(event)) return;
+      const message = event.data;
+      if (!message || message.type !== "intent.deliver") return;
+      const value = message.delivery;
+      if (!value || typeof value !== "object" || Array.isArray(value)) return;
+      const delivery = value;
+      if (typeof delivery.sender !== "string" || typeof delivery.archetype !== "string" || typeof delivery.action !== "string" || typeof delivery.convention !== "string") return;
+      pending.push(Object.freeze({
+        sender: delivery.sender,
+        archetype: delivery.archetype,
+        action: delivery.action,
+        convention: delivery.convention,
+        ...Object.prototype.hasOwnProperty.call(delivery, "payload") ? { payload: delivery.payload } : {}
+      }));
+      drain();
+    });
+    return {
+      onDelivery(handler) {
+        if (typeof handler !== "function") throw new TypeError("Intent delivery handler must be a function");
+        handlers.add(handler);
+        drain();
+        return subscriptionHandle(() => handlers.delete(handler));
+      },
+      onLegacy(topic, handler) {
+        legacy.set(handler, topic);
+        drain();
+        return () => legacy.delete(handler);
+      }
+    };
+  }
   function makeIntent() {
     const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
     const normalizeRequest = (value) => {
@@ -2311,6 +2380,7 @@ function nappletNamespacePrelude(domains) {
       );
     };
     return {
+      onDelivery: intentDelivery.onDelivery,
       invoke,
       open: (archetype, payload, opts) => invoke({
         archetype,
@@ -2490,6 +2560,7 @@ function nappletNamespacePrelude(domains) {
       onChanged: (callback) => domainEventHandle("fs.changed", callback, (msg) => msg.change)
     };
   }
+  const intentDelivery = allowed.has("intent") ? makeIntentDelivery() : void 0;
   const shell = makeShell();
   let inc;
   let identity;