@kehto/shell 0.22.0 → 0.23.0

package/README.md

@@ -76,24 +76,23 @@ the prior opener-only interpretation is obsolete.
 
 ### NAP-INTENT binding and delivery
 
-Kehto implements merged [NAP-INTENT at
-`5ac0490461ca6fec2f0d2e45b4835cf9bc08de24`](https://github.com/napplet/naps/blob/5ac0490461ca6fec2f0d2e45b4835cf9bc08de24/naps/NAP-INTENT.md).
-The protected `window.napplet.intent` binding accepts structured
-`invoke(request)` calls and `open(archetype, payload?, opts?)`. It defaults
-`action` to `open`, preserves an optional queryless convention, rejects
-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. 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
-and playground catalog builder are historical exact-contract consumers; preserve
-archived planning rather than presenting it as active guidance.
+Kehto follows [NAP-INTENT PR #106](https://github.com/napplet/naps/blob/fc121fc264615482143eda86125863d2e1f741a2/naps/NAP-INTENT.md) at `fc121fc264615482143eda86125863d2e1f741a2`. The protected binding supports
+`window.napplet.intent.invoke('napplet:profile/open?pubkey=abc%2B123')` and
+`invoke(uri, { payload, handler, handlerHint, behavior })`. Query fields decode
+once into text; `+` remains literal. An explicit payload cannot accompany an
+inner query, and a `#naddr` recommendation cannot accompany `handlerHint`.
+Unsupported options and caller-supplied sender data are rejected. Only a
+parent-originated correlated result can settle the call.
+
+Successful results identify retained delivery responsibility with `ok`,
+`archetype`, `action`, `convention`, and an opaque `handler`. A target receives
+one parent-attested `intent.deliver`, buffered by `onDelivery` until registration.
+Acceptance is separate from later target completion.
+
+Legacy object-form `invoke(request)` and `open(archetype, payload?, opts?)`
+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).
 
 ## Quick Start
 
@@ -256,8 +255,8 @@ 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
+Current manifests use a direct artifact `x` hash, plain-text `content`, role-matched
+`z`/`i` intent 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
@@ -275,5 +274,12 @@ 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.
+Delivery and URI invocation follow NAP-INTENT PR #106 at
+`fc121fc264615482143eda86125863d2e1f741a2`; the packaged SDK still trails that
+contract, as documented in the conformance policy.
+
+## Paja URL integration
+
+The shell normalizer also powers Paja intent links. See the
+[Paja guide](https://kehto.github.io/web/docs/packages/paja.html#nap-intent-links-and-lifecycle)
+for outer URL encoding, review, routing, and verified launcher behavior.

package/dist/index.d.ts

@@ -639,6 +639,38 @@ declare function renderNappletNamespacePrelude(options: NappletNamespacePreludeO
  */
 declare function injectNappletNamespacePrelude(html: string, options: NappletNamespacePreludeOptions): string;
 
+/** Canonical request fields produced from a NAP-INTENT convention URI. */
+interface NormalizedIntentUri {
+    archetype: string;
+    action: string;
+    convention: string;
+    payload?: unknown;
+    handlerHint?: {
+        address: string;
+        relays?: string[];
+    };
+    handler?: string;
+    behavior?: {
+        focus?: boolean;
+        reuse?: boolean;
+    };
+}
+/**
+ * Normalize a NAP-INTENT convention URI.
+ *
+ * The host and injected NIP-5D binding use the same normalizer factory.
+ *
+ * @param uri - Complete NAP-INTENT convention URI.
+ * @param options - Optional payload, handler, recommendation, and behavior hints.
+ * @returns The canonical request fields for `intent.invoke`.
+ * @example
+ * ```ts
+ * normalizeIntentUri('napplet:profile/open?pubkey=abc%2B123');
+ * // { archetype: 'profile', action: 'open', convention: 'napplet:profile/open', payload: { pubkey: 'abc+123' } }
+ * ```
+ */
+declare const normalizeIntentUri: (uri: unknown, options?: unknown) => NormalizedIntentUri;
+
 /** Source-list directives supported by the shell's meta-delivered CSP. */
 type NappletCspDirective = 'default-src' | 'script-src' | 'script-src-elem' | 'script-src-attr' | 'style-src' | 'style-src-elem' | 'style-src-attr' | 'img-src' | 'font-src' | 'connect-src' | 'worker-src' | 'child-src' | 'frame-src' | 'media-src' | 'object-src' | 'manifest-src' | 'base-uri' | 'form-action';
 /** Host replacements for individual CSP source lists; omitted directives retain defaults. */
@@ -1528,4 +1560,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 ManifestCache, type ManifestCacheEntry, type MediaProxy, type MediaProxyDeps, type NappletCspDirective, type NappletCspDirectives, type NappletCspOptions, type NappletNamespacePreludeOptions, type NappletSrcdocOptions, 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 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, injectNappletCsp, injectNappletNamespacePrelude, manifestCache, nappKeyRegistry, 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 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 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, injectNappletCsp, injectNappletNamespacePrelude, manifestCache, nappKeyRegistry, normalizeIntentUri, originRegistry, prepareNappletSrcdoc, renderNappletCspMeta, renderNappletNamespacePrelude, resolveShellEnvironment, sessionRegistry };

package/dist/index.js

@@ -1246,6 +1246,181 @@ function createShellBridge(hooks) {
   };
 }
 
+// src/intent-uri.ts
+function createIntentUriNormalizer() {
+  const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+  const fail = (message) => {
+    throw new TypeError(message);
+  };
+  const decode = (value, label) => {
+    try {
+      return decodeURIComponent(value);
+    } catch {
+      return fail(`Intent URI has malformed percent-encoding in ${label}`);
+    }
+  };
+  const decodeUtf8 = (bytes) => {
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(bytes));
+    } catch {
+      return fail("Intent URI fragment contains invalid UTF-8");
+    }
+  };
+  const decodeHint = (fragment) => {
+    if (!fragment.startsWith("naddr") || fragment !== fragment.toLowerCase()) {
+      return fail("Intent URI fragment must be a bare lowercase naddr");
+    }
+    const separator = fragment.lastIndexOf("1");
+    if (separator <= 0 || separator + 7 > fragment.length) fail("Intent URI fragment is not a valid naddr");
+    const alphabet = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+    const values = [];
+    for (const character of fragment.slice(separator + 1)) {
+      const value = alphabet.indexOf(character);
+      if (value < 0) fail("Intent URI fragment is not a valid naddr");
+      values.push(value);
+    }
+    const polymod = (input) => {
+      let checksum = 1;
+      for (const value of input) {
+        const top = checksum >>> 25;
+        checksum = (checksum & 33554431) << 5 ^ value;
+        if (top & 1) checksum ^= 996825010;
+        if (top & 2) checksum ^= 642813549;
+        if (top & 4) checksum ^= 513874426;
+        if (top & 8) checksum ^= 1027748829;
+        if (top & 16) checksum ^= 705979059;
+      }
+      return checksum;
+    };
+    const hrp = fragment.slice(0, separator);
+    const hrpValues = [...hrp].map((character) => character.charCodeAt(0) >>> 5).concat([0], [...hrp].map((character) => character.charCodeAt(0) & 31));
+    if (hrp !== "naddr" || polymod(hrpValues.concat(values)) !== 1) fail("Intent URI fragment is not a valid naddr");
+    const words = values.slice(0, -6);
+    const bytes = [];
+    let accumulator = 0;
+    let bits = 0;
+    for (const word of words) {
+      accumulator = accumulator << 5 | word;
+      bits += 5;
+      while (bits >= 8) {
+        bits -= 8;
+        bytes.push(accumulator >>> bits & 255);
+      }
+    }
+    if (bits >= 5 || (accumulator << 8 - bits & 255) !== 0) fail("Intent URI fragment is not a valid naddr");
+    let index = 0;
+    let identifier;
+    let pubkey;
+    let kind;
+    const relays = [];
+    while (index < bytes.length) {
+      if (index + 2 > bytes.length) fail("Intent URI fragment is not a valid naddr");
+      const type = bytes[index++];
+      const length = bytes[index++];
+      if (index + length > bytes.length) fail("Intent URI fragment is not a valid naddr");
+      const value = bytes.slice(index, index + length);
+      index += length;
+      if (type === 0) {
+        if (identifier !== void 0) fail("Intent URI fragment repeats its identifier");
+        identifier = decodeUtf8(value);
+      } else if (type === 1) {
+        const relay = decodeUtf8(value);
+        if (!relay) fail("Intent URI fragment has an empty relay hint");
+        relays.push(relay);
+      } else if (type === 2) {
+        if (pubkey !== void 0 || value.length !== 32) fail("Intent URI fragment has an invalid pubkey");
+        pubkey = value.map((part) => part.toString(16).padStart(2, "0")).join("");
+      } else if (type === 3) {
+        if (kind !== void 0 || value.length !== 4) fail("Intent URI fragment has an invalid kind");
+        kind = (value[0] << 24 >>> 0 | value[1] << 16 | value[2] << 8 | value[3]) >>> 0;
+      } else {
+        fail("Intent URI fragment has unsupported naddr data");
+      }
+    }
+    if (!identifier || !pubkey || kind !== 35129) fail("Intent URI fragment must recommend a named 35129 napplet");
+    return { address: `${kind}:${pubkey}:${identifier}`, ...relays.length > 0 ? { relays } : {} };
+  };
+  const normalizeHint = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) fail("Intent handlerHint must be an object");
+    const hint = value;
+    if (Object.keys(hint).some((key) => key !== "address" && key !== "relays")) fail("Intent handlerHint contains unsupported fields");
+    const address = hint.address;
+    if (typeof address !== "string" || !/^35129:[0-9a-f]{64}:.+$/u.test(address)) {
+      fail("Intent handlerHint address must be a named 35129 coordinate");
+    }
+    const relays = hint.relays;
+    if (relays !== void 0 && (!Array.isArray(relays) || relays.some((relay) => typeof relay !== "string" || relay.length === 0))) {
+      fail("Intent handlerHint relays must be non-empty text");
+    }
+    return { address, ...relays === void 0 ? {} : { relays: [...relays] } };
+  };
+  return function normalizeIntentUri2(uri, options) {
+    if (typeof uri !== "string") throw new TypeError("Intent URI must be text");
+    const match = /^napplet:([^/?#\s]+)\/([^/?#\s]+)(?:\?([^#]*))?(?:#(.*))?$/u.exec(uri);
+    if (match === null) return fail("Intent URI must be napplet:<archetype>/<action>");
+    const archetype = match[1];
+    const action = match[2];
+    if (!/^[a-z0-9][a-z0-9-]*$/u.test(archetype) || !/^[a-z0-9][a-z0-9-]*$/u.test(action)) {
+      fail("Intent URI archetype and action must be lowercase slugs");
+    }
+    const query = match[3];
+    const fragment = match[4];
+    const supplied = options === void 0 ? {} : options;
+    if (!supplied || typeof supplied !== "object" || Array.isArray(supplied)) fail("Intent options must be an object");
+    const parsedOptions = supplied;
+    if (Object.keys(parsedOptions).some((key) => key !== "payload" && key !== "handler" && key !== "handlerHint" && key !== "behavior")) {
+      fail("Intent options contain unsupported fields");
+    }
+    const handler = parsedOptions.handler;
+    if (handler !== void 0 && (typeof handler !== "string" || handler.length === 0)) {
+      fail("Intent handler must be non-empty text");
+    }
+    let behavior;
+    if (parsedOptions.behavior !== void 0) {
+      if (!parsedOptions.behavior || typeof parsedOptions.behavior !== "object" || Array.isArray(parsedOptions.behavior)) fail("Intent behavior must be an object");
+      const value = parsedOptions.behavior;
+      if (Object.keys(value).some((key) => key !== "focus" && key !== "reuse") || hasOwn(value, "focus") && typeof value.focus !== "boolean" || hasOwn(value, "reuse") && typeof value.reuse !== "boolean") fail("Intent behavior contains unsupported fields");
+      behavior = {
+        ...hasOwn(value, "focus") ? { focus: value.focus } : {},
+        ...hasOwn(value, "reuse") ? { reuse: value.reuse } : {}
+      };
+    }
+    let payload;
+    if (query !== void 0) {
+      if (hasOwn(parsedOptions, "payload")) fail("Intent URI query cannot accompany options.payload");
+      if (query.length > 0) {
+        const fields = /* @__PURE__ */ Object.create(null);
+        for (const field of query.split("&")) {
+          const equal = field.indexOf("=");
+          if (equal <= 0 || field.indexOf("=", equal + 1) >= 0) fail("Intent URI query fields must be name=value");
+          const name = decode(field.slice(0, equal), "a query name");
+          const value = decode(field.slice(equal + 1), "a query value");
+          if (!name || hasOwn(fields, name)) fail("Intent URI query names must be unique after decoding");
+          Object.defineProperty(fields, name, { value, enumerable: true, writable: true, configurable: true });
+        }
+        payload = fields;
+      }
+    } else if (hasOwn(parsedOptions, "payload")) {
+      payload = parsedOptions.payload;
+    }
+    if (fragment !== void 0) {
+      if (!fragment) fail("Intent URI fragment must be a bare naddr");
+      if (parsedOptions.handlerHint !== void 0) fail("Intent URI fragment cannot accompany options.handlerHint");
+    }
+    const handlerHint = fragment === void 0 ? parsedOptions.handlerHint === void 0 ? void 0 : normalizeHint(parsedOptions.handlerHint) : decodeHint(fragment);
+    return {
+      archetype,
+      action,
+      convention: `napplet:${archetype}/${action}`,
+      ...payload === void 0 ? {} : { payload },
+      ...handlerHint === void 0 ? {} : { handlerHint },
+      ...handler === void 0 ? {} : { handler },
+      ...behavior === void 0 ? {} : { behavior }
+    };
+  };
+}
+var normalizeIntentUri = createIntentUriNormalizer();
+
 // src/napplet-namespace.ts
 function uniqueBareDomains(domains) {
   const seen = /* @__PURE__ */ new Set();
@@ -1265,7 +1440,7 @@ function scriptJson(value) {
 }
 function renderNappletNamespacePrelude(options) {
   const domains = uniqueBareDomains(["shell", ...options.domains]);
-  return `<script data-kehto-nip5d-injection>(${nappletNamespacePrelude.toString()})(${scriptJson(domains)});</script>`;
+  return `<script data-kehto-nip5d-injection>(${nappletNamespacePrelude.toString()})(${scriptJson(domains)}, (${createIntentUriNormalizer.toString()})());</script>`;
 }
 function injectNappletNamespacePrelude(html, options) {
   const prelude = renderNappletNamespacePrelude(options);
@@ -1281,7 +1456,7 @@ function injectNappletNamespacePrelude(html, options) {
   }
   return `${prelude}${html}`;
 }
-function nappletNamespacePrelude(domains) {
+function nappletNamespacePrelude(domains, normalizeIntentUri2) {
   const target = window;
   const allowed = new Set(domains);
   const requestTimeoutMs = 3e4;
@@ -2324,7 +2499,14 @@ function nappletNamespacePrelude(domains) {
   }
   function makeIntent() {
     const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-    const normalizeRequest = (value) => {
+    let warnedLegacyObject = false;
+    const warnLegacyObject = () => {
+      if (warnedLegacyObject) return;
+      warnedLegacyObject = true;
+      console.warn("[KEHTO_COMPAT_INTENT_OBJECT_INVOKE] Object-form intent.invoke/open is deprecated; use intent.invoke(uri, options) or intent.open(uri, options). Warns once per napplet. See docs/compatibility.md.");
+    };
+    const normalizeLegacyRequest = (value) => {
+      warnLegacyObject();
       if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new TypeError("Intent request must be an object");
       }
@@ -2332,7 +2514,7 @@ function nappletNamespacePrelude(domains) {
       if (hasOwn(supplied, "sender")) {
         throw new TypeError("Intent callers cannot supply sender");
       }
-      const allowed2 = ["archetype", "action", "convention", "payload", "handler", "behavior"];
+      const allowed2 = ["archetype", "action", "convention", "payload", "handler", "handlerHint", "behavior"];
       if (Object.keys(supplied).some((field) => !allowed2.includes(field))) {
         throw new TypeError("Intent request contains unsupported fields");
       }
@@ -2343,51 +2525,63 @@ function nappletNamespacePrelude(domains) {
       if (typeof action !== "string" || action.length === 0) {
         throw new TypeError("Intent action must be a non-empty string");
       }
-      if (supplied.convention !== void 0 && (typeof supplied.convention !== "string" || !/^napplet:[^/?#\s]+\/[^/?#\s]+$/.test(supplied.convention))) {
-        throw new TypeError("Intent convention must be queryless");
+      const uri = supplied.convention === void 0 ? `napplet:${supplied.archetype}/${action}` : supplied.convention;
+      if (typeof uri !== "string") throw new TypeError("Intent convention must be text");
+      if (uri.includes("?") || uri.includes("#")) throw new TypeError("Legacy intent convention must be queryless");
+      return normalizeIntentUri2(uri, {
+        ...hasOwn(supplied, "payload") ? { payload: supplied.payload } : {},
+        ...hasOwn(supplied, "handler") ? { handler: supplied.handler } : {},
+        ...hasOwn(supplied, "handlerHint") ? { handlerHint: supplied.handlerHint } : {},
+        ...hasOwn(supplied, "behavior") ? { behavior: supplied.behavior } : {}
+      });
+    };
+    const requestInvoke = (normalized) => request(
+      {
+        type: "intent.invoke",
+        request: normalized
+      },
+      "intent.invoke.result",
+      (msg) => fieldOrThrow(msg, "result", "intent.invoke.result missing result")
+    );
+    const invoke = (uri, options) => {
+      const normalized = typeof uri === "string" ? normalizeIntentUri2(uri, options) : normalizeLegacyRequest(uri);
+      return requestInvoke(normalized);
+    };
+    const open = (uri, options, legacyOptions) => {
+      if (typeof uri === "string" && uri.startsWith("napplet:") && legacyOptions === void 0) {
+        const normalized2 = normalizeIntentUri2(uri, options);
+        if (normalized2.action !== "open") throw new TypeError("intent.open requires a /open URI");
+        return requestInvoke(normalized2);
       }
-      if (supplied.handler !== void 0 && (typeof supplied.handler !== "string" || supplied.handler.length === 0)) {
-        throw new TypeError("Intent handler must be a non-empty string");
+      if (typeof uri !== "string" || !uri) throw new TypeError("Intent archetype must be non-empty text");
+      warnLegacyObject();
+      if (legacyOptions !== void 0 && (!legacyOptions || typeof legacyOptions !== "object" || Array.isArray(legacyOptions))) {
+        throw new TypeError("Intent options must be an object");
       }
-      const behaviorValue = supplied?.behavior;
-      const behavior = behaviorValue && typeof behaviorValue === "object" ? behaviorValue : void 0;
-      if (behaviorValue !== void 0 && (!behavior || Array.isArray(behaviorValue) || Object.keys(behavior).some((field) => field !== "focus" && field !== "newWindow" && field !== "reuse") || hasOwn(behavior, "focus") && typeof behavior.focus !== "boolean" || hasOwn(behavior, "newWindow") && typeof behavior.newWindow !== "boolean" || hasOwn(behavior, "reuse") && typeof behavior.reuse !== "boolean")) {
-        throw new TypeError("Intent behavior contains unsupported fields");
+      const legacy = legacyOptions;
+      const convention = legacy?.convention === void 0 ? `napplet:${uri}/open` : legacy.convention;
+      if (typeof convention !== "string" || convention.includes("?") || convention.includes("#")) {
+        throw new TypeError("Legacy intent convention must be queryless");
       }
-      const sanitizedBehavior = {
-        ...typeof behavior?.focus === "boolean" ? { focus: behavior.focus } : {},
-        ...typeof behavior?.newWindow === "boolean" ? { newWindow: behavior.newWindow } : {},
-        ...typeof behavior?.reuse === "boolean" ? { reuse: behavior.reuse } : {}
-      };
-      return {
-        archetype: supplied.archetype,
-        action,
-        ...typeof supplied.convention === "string" ? { convention: supplied.convention } : {},
-        ...hasOwn(supplied, "payload") ? { payload: supplied.payload } : {},
-        ...typeof supplied.handler === "string" ? { handler: supplied.handler } : {},
-        ...Object.keys(sanitizedBehavior).length === 0 ? {} : { behavior: sanitizedBehavior }
-      };
-    };
-    const invoke = (value) => {
-      const normalized = normalizeRequest(value);
-      return request(
-        {
-          type: "intent.invoke",
-          request: normalized
-        },
-        "intent.invoke.result",
-        (msg) => fieldOrThrow(msg, "result", "intent.invoke.result missing result")
-      );
+      const normalized = normalizeIntentUri2(`napplet:${uri}/open`, {
+        ...options === void 0 ? {} : { payload: options },
+        ...legacy === void 0 ? {} : Object.fromEntries(
+          Object.entries(legacy).filter(([key]) => key !== "convention")
+        )
+      });
+      const legacyNormalized = convention === `napplet:${uri}/open` ? normalized : normalizeIntentUri2(convention, {
+        ...options === void 0 ? {} : { payload: options },
+        ...legacy === void 0 ? {} : Object.fromEntries(
+          Object.entries(legacy).filter(([key]) => key !== "convention")
+        )
+      });
+      if (legacyNormalized.action !== "open") throw new TypeError("intent.open requires a /open URI");
+      return requestInvoke(legacyNormalized);
     };
     return {
       onDelivery: intentDelivery.onDelivery,
       invoke,
-      open: (archetype, payload, opts) => invoke({
-        archetype,
-        action: "open",
-        ...payload === void 0 ? {} : { payload },
-        ...opts
-      }),
+      open,
       available: (archetype) => request(
         { type: "intent.available", archetype },
         "intent.available.result",
@@ -2905,6 +3099,7 @@ export {
   injectNappletNamespacePrelude,
   manifestCache,
   nappKeyRegistry,
+  normalizeIntentUri,
   originRegistry,
   prepareNappletSrcdoc,
   renderNappletCspMeta,