@kehto/services 0.22.0 → 0.23.0

package/README.md

@@ -52,35 +52,24 @@ Current draft posture:
 
 ## NAP-INTENT manifest resolver
 
-Kehto follows merged [NAP-INTENT at
-`5ac0490461ca6fec2f0d2e45b4835cf9bc08de24`](https://github.com/napplet/naps/blob/5ac0490461ca6fec2f0d2e45b4835cf9bc08de24/naps/NAP-INTENT.md).
-Callers invoke a stable, queryless `napplet:<archetype>/<action>` convention.
-Installed verified manifest tags produce exact `{ slug, convention }`
-declarations; numbered protocol names, trailing metadata, and payload inspection
-do not select a handler.
-
-- `manifestToIntentCatalogEntry()` converts resolved manifest
-  `{ dTag, title?, archetypes: [{ slug, convention }] }` data into exact
-  candidates with `actions` and `conventions`.
-- `createCatalogIntentResolver()` filters by exact convention, applies the
-  user-owned default/chooser/explicit-authorization policy, and asks an
-  `IntentTargetController` to create/focus a target and dispatch the selected
-  convention.
-- `createIntentService()` validates source envelopes, uses the runtime-attested
-  sender, returns one final canonical `IntentResult`, and broadcasts catalog
-  changes through recipient-policy-aware runtime sends.
-
-`ok: true` means the selected target was ready and the convention was dispatched.
-The result includes `handled`, `handler`, `windowId`, and `convention`. The
-target receives the convention and opaque payload through one runtime-attested
-`inc.event`; there is no separate `intent.deliver` lifecycle.
-
-Paja currently exposes only an exact-contract development simulator, and the
-playground currently exposes only a verified-manifest catalog builder. Phase
-105 completed released `@napplet/*` package adoption plus the persistent live
-catalog/controller and feed-to-profile flow. Its public `Intent*` types are
-canonical releases from `@napplet/core` / `@napplet/nap`, not a local mirror;
-successful results report completed target dispatch.
+Kehto follows [NAP-INTENT PR #106](https://github.com/napplet/naps/blob/fc121fc264615482143eda86125863d2e1f741a2/naps/NAP-INTENT.md) at `fc121fc264615482143eda86125863d2e1f741a2`. The shell binding normalizes URI calls into a
+queryless convention and separate opaque payload before service dispatch.
+
+- `manifestToIntentCatalogEntry()` converts verified `{ catalogId, title?, archetypes: [{ slug, convention, params }] }` facts into exact contracts.
+- `createCatalogIntentResolver()` applies authorized explicit selection, an explicit chooser, or default → recommendation → compatible choice. Payload contents never select a handler.
+- `createIntentService()` requires `resolveSender(windowId)`, derives the sender from the authenticated endpoint, validates requests, and returns one canonical result.
+
+`ok: true` means the controller retained responsibility for delivery. It contains
+`archetype`, `action`, `convention`, and the opaque handler ID. It does not expose
+a window ID or promise target completion. The controller waits for the current
+target's authenticated readiness and sends one `intent.deliver`; host observers
+receive later completion or failure without a second source result. Source
+teardown does not cancel accepted work. `intent.onDelivery` buffers arrivals;
+INC is not required.
+
+Paja and playground use verified persistent catalogs separately from live frames.
+The installed `@napplet/nap@0.32.0` types predate this contract; the bounded local
+canonical types and their removal condition are documented below.
 
 ## Quick Start
 
@@ -627,7 +616,7 @@ complete normal result without `error`: this explicit policy reconciles the
 draft error-only example without a mixed theme/error extension.
 
 ### Types
-`AudioSource`, `AudioServiceOptions`, `Notification`, `NotificationServiceOptions`, `IdentityServiceOptions`, `RelayPoolServiceOptions`, `CacheServiceOptions`, `CoordinatedRelayOptions`, `KeysServiceOptions`, `MediaServiceOptions`, `NotifyServiceOptions`, `NotifyPresentation`, `NotifyInteractionMessage`, `ThemeServiceOptions`, `ThemeService`, `IntentOpenOptions`, `IntentRequest`, `IntentResult`, `IntentCandidate`, `IntentAvailability`, `IntentResolver`, `IntentTargetController`, `IntentDispatchParams`, `IntentTargetDispatch`, `BleServiceOptions`, `BleServiceContext`, `WebrtcServiceOptions`, `WebrtcServiceContext`, `DmServiceOptions`, `DmAdapter`, `DmRelayPool`, `Nip17DmAdapterOptions`, `NdrDmAdapterOptions`, `CordnDmAdapterOptions`.
+`AudioSource`, `AudioServiceOptions`, `Notification`, `NotificationServiceOptions`, `IdentityServiceOptions`, `RelayPoolServiceOptions`, `CacheServiceOptions`, `CoordinatedRelayOptions`, `KeysServiceOptions`, `MediaServiceOptions`, `NotifyServiceOptions`, `NotifyPresentation`, `NotifyInteractionMessage`, `ThemeServiceOptions`, `ThemeService`, `IntentRequest`, `IntentResult`, `IntentCandidate`, `IntentAvailability`, `IntentResolver`, `IntentTargetController`, `IntentDispatchParams`, `IntentTargetDispatch`, `BleServiceOptions`, `BleServiceContext`, `WebrtcServiceOptions`, `WebrtcServiceContext`, `DmServiceOptions`, `DmAdapter`, `DmRelayPool`, `Nip17DmAdapterOptions`, `NdrDmAdapterOptions`, `CordnDmAdapterOptions`.
 
 ## API Reference
 
@@ -637,3 +626,17 @@ Generated API module: `docs/api/modules/_kehto_services.html` (run `pnpm docs:ap
 ## License
 
 MIT
+
+## NIP-5D event compatibility
+
+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
+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).
+
+## Canonical intent contracts
+
+`@kehto/services` temporarily owns the canonical NAP-INTENT PR #106 contracts because `@napplet/nap@0.32.0` has not yet published them. Candidates use opaque `id` plus exact `contracts`; successful results contain only `ok`, `archetype`, `action`, `convention`, and `handler` (never `handled`, `windowId`, or `newWindow`). `createIntentService` requires `resolveSender(windowId)` and rejects caller-supplied sender fields. `IntentResolverContext.sourceWindowId` and `IntentDispatchParams.sourceWindowId` are host-only correlation fields: they must never appear in `intent.deliver` or `intent.invoke.result`. A target controller accepts retained work as `{ completion }`; completion failure is host observation, not a second canonical result. Remove these local types only when an upstream package exports the checked PR #106 surface and Kehto's service/runtime regression suite proves direct replacement.

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { ServiceHandler, Signer, RelayEventResult, ServiceRuntimeContext } from '@kehto/runtime';
 import { IdentityGetProfileMessage, IdentityGetProfileResultMessage, IdentityGetFollowsMessage, IdentityGetFollowsResultMessage, IdentityGetListMessage, IdentityGetListResultMessage, IdentityGetZapsMessage, IdentityGetZapsResultMessage, IdentityGetMutesMessage, IdentityGetMutesResultMessage, IdentityGetBlockedMessage, IdentityGetBlockedResultMessage, IdentityGetBadgesMessage, IdentityGetBadgesResultMessage } from '@napplet/nap/identity/types';
-import { NostrFilter, NostrEvent, EventTemplate, IntentRequest, IntentResult, IntentAvailability, IntentBehavior, IntentCandidate, LinkOpenOptions, LinkOpenResult, ListSupport, ListRef, ListItem, ListOptions, ListMutationResult, SerialEvent, SerialOpenRequest, SerialOpenResult, BleEvent, BleOpenRequest, BleOpenResult, BleService, BleAttribute, BleWriteOptions, WebrtcEvent, WebrtcOpenRequest, WebrtcOpenResult, CommonProfileTarget, CommonProfileResult, CommonFollowsResult, CommonActionResult, CommonReaction, CommonReportTarget, CommonReportReason, DmStatus, DmConversationQuery, DmConversationPage, DmMessageQuery, DmMessagePage, DmSendRequest, DmSendResult, DmSubscribeRequest, DmMessage, DmSubscription, DmOk, DmHexPubkey, FsInfo, FsPickOptions, FsPickResult, FsMetadata, FsDirectoryEntry, FsReadOptions, FsReadResult, FsWriteOptions, FsWriteResult, FsMkdirOptions, FsWatchOptions, FsChange, FsError } from '@napplet/core';
-export { DmConversation, DmConversationPage, DmConversationQuery, DmHexPubkey, DmMessage, DmMessagePage, DmMessageQuery, DmMessageStatus, DmOk, DmPeer, DmSendRequest, DmSendResult, DmStatus, DmSubscribeRequest, DmSubscription, DmTimestamp, IntentAvailability, IntentBehavior, IntentCandidate, IntentHandlerPreference, IntentOpenOptions, IntentRequest, IntentResult } from '@napplet/core';
+import { NostrFilter, NostrEvent, EventTemplate, LinkOpenOptions, LinkOpenResult, ListSupport, ListRef, ListItem, ListOptions, ListMutationResult, SerialEvent, SerialOpenRequest, SerialOpenResult, BleEvent, BleOpenRequest, BleOpenResult, BleService, BleAttribute, BleWriteOptions, WebrtcEvent, WebrtcOpenRequest, WebrtcOpenResult, CommonProfileTarget, CommonProfileResult, CommonFollowsResult, CommonActionResult, CommonReaction, CommonReportTarget, CommonReportReason, DmStatus, DmConversationQuery, DmConversationPage, DmMessageQuery, DmMessagePage, DmSendRequest, DmSendResult, DmSubscribeRequest, DmMessage, DmSubscription, DmOk, DmHexPubkey, FsInfo, FsPickOptions, FsPickResult, FsMetadata, FsDirectoryEntry, FsReadOptions, FsReadResult, FsWriteOptions, FsWriteResult, FsMkdirOptions, FsWatchOptions, FsChange, FsError } from '@napplet/core';
+export { DmConversation, DmConversationPage, DmConversationQuery, DmHexPubkey, DmMessage, DmMessagePage, DmMessageQuery, DmMessageStatus, DmOk, DmPeer, DmSendRequest, DmSendResult, DmStatus, DmSubscribeRequest, DmSubscription, DmTimestamp } from '@napplet/core';
 import { MediaMetadata, MediaAction } from '@napplet/nap/media/types';
 export { MediaAction } from '@napplet/nap/media/types';
 import { NotifyActionMessage, NotifyClickedMessage, NotifyDismissedMessage, NotifySendMessage, NotifyChannelRegisterMessage, NotifyControl } from '@napplet/nap/notify/types';
@@ -2090,219 +2090,162 @@ interface HttpUploaderOptions {
  */
 declare function createHttpUploader(options: HttpUploaderOptions): Uploader;
 
-/**
- * intent-service.ts — NAP-INTENT (archetype intent dispatch) reference service.
- *
- * Shell-side handler for the NAP-INTENT wire protocol. It is a pure envelope
- * router: it validates `intent.*` envelopes, delegates archetype resolution,
- * default handling and target dispatch to an injected
- * {@link IntentResolver}, then posts correlated result and push messages back
- * to the napplet.
- *
- * The resolver is injected (options-as-bridge) so this service has no shell or
- * target-lifecycle dependency and is fully unit-testable. A concrete
- * catalog-backed resolver ships alongside as {@link createCatalogIntentResolver}.
- *
- * ──────────────────────────── Responsibilities ────────────────────────────
- *   Inbound:  intent.invoke, intent.available, intent.handlers
- *   Outbound: intent.invoke.result, intent.available.result,
- *             intent.handlers.result, intent.changed
- *
- * The shell owns archetype→handler resolution, the user's default-handler
- * preference, chooser, and target lifecycle policy behind the
- * {@link IntentResolver}. This service only marshals the wire protocol and
- * fans `intent.changed` pushes out to eligible napplets.
- *
- * @example
- * ```ts
- * import { createIntentService, createCatalogIntentResolver } from '@kehto/services';
- *
- * const resolver = createCatalogIntentResolver({ loadCatalog, targets });
- * runtime.registerService('intent', createIntentService({ resolver }));
- * ```
- *
- * @packageDocumentation
- */
+/** Canonical NAP-INTENT contracts pending upstream @napplet/nap publication. */
+/** Lifecycle hints that remain subject to host workspace policy. */
+interface IntentBehavior {
+    readonly focus?: boolean;
+    readonly reuse?: boolean;
+}
+/** A verified named-manifest recommendation; relay URLs are discovery hints only. */
+interface IntentHandlerHint {
+    readonly address: string;
+    readonly relays?: readonly string[];
+}
+/** One advertised stable convention and its ordered, untyped parameter names. */
+interface IntentContract {
+    readonly convention: string;
+    readonly params: readonly string[];
+}
+/** Normalized runtime request. `action` and `convention` are always URI-derived. */
+interface IntentRequest {
+    readonly archetype: string;
+    readonly action: string;
+    readonly convention: string;
+    readonly payload?: unknown;
+    readonly handler?: string;
+    readonly handlerHint?: IntentHandlerHint;
+    readonly behavior?: IntentBehavior;
+}
+/** Runtime-assigned catalog candidate; its ID is never a bare manifest d-tag. */
+interface IntentCandidate {
+    readonly id: string;
+    readonly title?: string;
+    readonly actions: readonly string[];
+    readonly conventions: readonly string[];
+    readonly contracts: readonly IntentContract[];
+    readonly isDefault?: boolean;
+}
+/** Candidate availability for one manifest-advertised role. */
+interface IntentAvailability {
+    readonly archetype: string;
+    readonly available: boolean;
+    readonly candidates: readonly IntentCandidate[];
+    readonly hasDefault: boolean;
+}
+/** Successful results mean retained delivery responsibility, never completion. */
+type IntentResult = {
+    readonly ok: true;
+    readonly archetype: string;
+    readonly action: string;
+    readonly convention: string;
+    readonly handler: string;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/** Runtime-attested target delivery after it becomes ready. */
+interface IntentDelivery {
+    readonly sender: string;
+    readonly archetype: string;
+    readonly action: string;
+    readonly convention: string;
+    readonly payload?: unknown;
+}
+
+/** NAP-INTENT wire service using canonical Kehto contracts. */
 
-/** Context passed to {@link IntentResolver.invoke} for trust/attribution. */
+/** Runtime-attested source catalog identity passed to intent policy. */
 interface IntentResolverContext {
-    /** Runtime-attested dTag of the napplet that issued the request. */
-    sender: string;
+    readonly sender: string;
+    /** Authenticated runtime source, internal to host policy and never wire data. */
+    readonly sourceWindowId?: string;
 }
-/**
- * Abstract intent resolver. Implementors own the installed-napplet catalog,
- * archetype→handler resolution, the user's default-handler preference, the
- * chooser and target lifecycle/delivery policy. The
- * service translates wire envelopes into these calls and back.
- */
+/** Installed-catalog resolver and lifecycle policy. */
 interface IntentResolver {
-    /**
-     * Resolve and dispatch the request.
-     *
-     * @param request - Validated normalized intent request.
-     * @param context - Runtime-attested source identity.
-     * @returns The canonical structured dispatch result.
-     */
     invoke(request: IntentRequest, context: IntentResolverContext): IntentResult | Promise<IntentResult>;
-    /** Report whether the runtime can currently satisfy `archetype`, and how. */
     available(archetype: string): IntentAvailability | Promise<IntentAvailability>;
-    /** Report availability for every archetype the runtime can currently satisfy. */
-    handlers(): IntentAvailability[] | Promise<IntentAvailability[]>;
-    /**
-     * Register for availability changes (a napplet installed/removed, or a default
-     * handler changed). The service forwards each change to served napplets as an
-     * `intent.changed` push. Returns an unsubscribe handle. Resolvers whose
-     * catalog never changes at runtime MAY omit this.
-     */
+    handlers(): readonly IntentAvailability[] | Promise<readonly IntentAvailability[]>;
     onChanged?(listener: (availability: IntentAvailability) => void): () => void;
 }
-/** Options for {@link createIntentService}. */
+/** Service dependencies including a source-bound verified catalog identity lookup. */
 interface IntentServiceOptions {
-    /** The intent resolver the shell uses to route archetypes. Required. */
-    resolver: IntentResolver;
+    readonly resolver: IntentResolver;
+    /** Maps an authenticated runtime window to its verified catalog ID. */
+    readonly resolveSender: (windowId: string) => string | undefined;
 }
 /**
- * Create the NAP-INTENT service handler.
+ * Create the NAP-INTENT service. Request data does not carry a sender field;
+ * unknown fields are rejected and the sender always comes from `resolveSender`.
+ *
+ * @param options - Resolver plus authenticated window-to-catalog identity lookup.
+ * @returns A runtime service handler for `intent.*` messages.
  *
- * @param options - Must provide an {@link IntentResolver}.
- * @returns A `ServiceHandler` ready for `runtime.registerService('intent', handler)`.
- * @throws If `options.resolver` is missing.
+ * @example
+ * ```ts
+ * runtime.registerService('intent', createIntentService({
+ *   resolver,
+ *   resolveSender: (windowId) => verifiedCatalogIdForWindow(windowId),
+ * }));
+ * ```
  */
 declare function createIntentService(options: IntentServiceOptions): ServiceHandler;
 
-/**
- * catalog-intent-resolver.ts — NAP-INTENT concrete {@link IntentResolver}.
- *
- * A reference resolver backed by installed, verified NIP-5A manifest
- * archetype/convention tags plus host-supplied user policy. Catalog order and
- * payload contents never select a handler.
- *
- * Selection policy:
- *   1. Filter installed candidates by declared action and convention support.
- *   2. Require positive host authorization for an explicit handler dTag.
- *   3. Otherwise use an explicit chooser, a compatible user default, the sole
- *      compatible candidate, or an injected chooser.
- *   4. Reject ambiguity when no chooser policy exists.
- *
- * The catalog, defaults, chooser, authorization hook, and target controller are
- * injected, so this resolver has no shell, manifest, or DOM dependency.
- *
- * @packageDocumentation
- */
+/** Verified-manifest NAP-INTENT catalog resolution. */
 
-/** The exact manifest-derived conventions a napplet fulfills for one archetype. */
+/** Exact contracts fulfilled by a catalog entry for one role. */
 interface IntentArchetypeSupport {
-    /** Verbs derived from this napplet's accepted conventions. */
-    actions: string[];
-    /** Stable queryless convention identities declared by the manifest. */
-    conventions: string[];
+    readonly contracts: readonly IntentContract[];
 }
-/**
- * One installed napplet's intent surface, derived from its signed NIP-5A
- * manifest. Keyed by archetype slug so a single napplet can fulfill several
- * roles.
- */
+/** A verified installed napplet, keyed by a runtime-assigned opaque catalog ID. */
 interface IntentCatalogEntry {
-    /** The napplet's dTag. */
-    dTag: string;
-    /** Human-readable title from the manifest. */
-    title?: string;
-    /** Archetype slug to exact manifest-derived support. */
-    archetypes: Record<string, IntentArchetypeSupport>;
+    readonly id: string;
+    readonly title?: string;
+    readonly archetypes: Readonly<Record<string, IntentArchetypeSupport>>;
 }
-/** Exact values dispatched to one selected intent target. */
+/** Immutable delivery values retained by the target controller after acceptance. */
 interface IntentDispatchParams {
-    /** Selected target napplet dTag. */
     readonly handler: string;
-    /** Runtime-attested source napplet dTag. */
     readonly sender: string;
-    /** Requested target archetype. */
     readonly archetype: string;
-    /** Requested action. */
     readonly action: string;
-    /** Selected stable convention used to deliver the payload. */
     readonly convention: string;
-    /** Opaque convention payload. */
     readonly payload?: unknown;
-    /** Copied target lifecycle hints. */
     readonly behavior?: Readonly<IntentBehavior>;
+    /** Authenticated host-only source correlation. Never serialize into delivery. */
+    readonly sourceWindowId?: string;
 }
-/** Result returned by a host after creating/focusing and dispatching to a target. */
-interface IntentTargetDispatch {
-    /** Shell-assigned target window identifier. */
-    readonly windowId: string;
+/** Retained work observable by the host without a second source result. */
+interface IntentTargetAcceptance {
+    readonly completion: Promise<void>;
 }
-/** Host controller that owns target lifecycle and convention delivery policy. */
+/** Owns target lifecycle and retains delivery before returning to the source. */
 interface IntentTargetController {
-    /**
-     * Create or focus the selected target, wait until it can receive the
-     * convention, then enqueue delivery through the host's ordinary carrier.
-     *
-     * @param params - Immutable selected target and dispatch values.
-     * @returns The created/focused target identity.
-     */
-    dispatch(params: IntentDispatchParams): IntentTargetDispatch | Promise<IntentTargetDispatch>;
+    accept(params: IntentDispatchParams): IntentTargetAcceptance;
 }
-/** Options for {@link createCatalogIntentResolver}. */
+/** Catalog, user-policy, and lifecycle hooks for the reference resolver. */
 interface CatalogIntentResolverOptions {
-    /** Return the installed-napplet catalog sourced from signed manifests. */
-    loadCatalog(): IntentCatalogEntry[] | Promise<IntentCatalogEntry[]>;
-    /** Target controller that creates/readies the selected target and dispatches its convention. */
+    loadCatalog(): readonly IntentCatalogEntry[] | Promise<readonly IntentCatalogEntry[]>;
     targets: IntentTargetController;
-    /**
-     * Return the user's default handler dTag for an archetype.
-     *
-     * @param archetype - Normalized archetype slug.
-     * @returns The user-selected default dTag, or `undefined`.
-     */
     getDefaultHandler?(archetype: string): string | undefined;
-    /**
-     * Ask user policy to select one exact-compatible candidate.
-     *
-     * @param archetype - Normalized archetype slug.
-     * @param candidates - Only candidates with an exact matching contract.
-     * @param sender - Runtime-attested source napplet dTag.
-     * @returns A candidate dTag, or `undefined` when the user cancels.
-     */
-    chooseHandler?(archetype: string, candidates: IntentCandidate[], sender: string): string | undefined | Promise<string | undefined>;
-    /**
-     * Authorize a caller's explicit handler dTag preference.
-     *
-     * @param sender - Runtime-attested source napplet dTag.
-     * @param handler - Explicit requested handler dTag.
-     * @param request - Normalized intent request.
-     * @param candidate - Installed exact-compatible candidate.
-     * @returns `true` only when explicit targeting is user-authorized.
-     */
-    authorizeExplicitHandler?(sender: string, handler: string, request: IntentRequest, candidate: IntentCandidate): boolean | Promise<boolean>;
+    chooseHandler?(archetype: string, candidates: readonly IntentCandidate[], sender: string): string | undefined | Promise<string | undefined>;
+    authorizeExplicitHandler?(sender: string, handler: string, request: IntentRequest, candidate: IntentCandidate, context?: IntentResolverContext): boolean | Promise<boolean>;
+    /** Resolve a valid recommendation only to an already compatible verified entry. */
+    resolveHandlerHint?(hint: IntentHandlerHint, candidates: readonly IntentCandidate[]): string | undefined | Promise<string | undefined>;
 }
-/**
- * A {@link IntentResolver} backed by a catalog, with a host hook to announce
- * catalog/default changes.
- */
 interface CatalogIntentResolver extends IntentResolver {
-    /**
-     * Announce that the catalog or default handler for `archetype` changed.
-     *
-     * @param archetype - Changed archetype slug.
-     * @returns Nothing.
-     */
     notifyChanged(archetype: string): void;
 }
 /**
- * Create a catalog-backed NAP-INTENT resolver.
+ * Create a catalog-backed resolver from verified manifest contracts.
  *
- * @param options - Catalog loader and target controller plus optional user
- *   default, chooser, and explicit-handler authorization hooks.
- * @returns A catalog-backed resolver.
- * @throws If required catalog or target-controller options are missing.
+ * @param options - Verified catalog, selection policy, and target lifecycle hooks.
+ * @returns A resolver suitable for {@link createIntentService}.
  *
  * @example
  * ```ts
  * const resolver = createCatalogIntentResolver({
- *   loadCatalog: () => installedNapplets,
- *   targets: { dispatch: (params) => openAndDispatch(params) },
- *   getDefaultHandler: (archetype) => userDefaults[archetype],
+ *   loadCatalog: () => installedCatalog,
+ *   targets: { accept: (params) => ({ completion: deliverToTarget(params) }) },
  * });
  * ```
  */
@@ -2311,7 +2254,7 @@ declare function createCatalogIntentResolver(options: CatalogIntentResolverOptio
 /**
  * manifest-intent-catalog.ts — signed-manifest → NAP-INTENT catalog adapter.
  *
- * Adapts a resolved NIP-5A/5D napplet manifest's archetype tags into an
+ * Adapts a resolved NIP-5D manifest's normalized routing declarations into an
  * {@link IntentCatalogEntry} — the shape `createCatalogIntentResolver.loadCatalog`
  * consumes. This lets NAP-INTENT availability and handler candidacy flow from
  * verified manifest tags rather than host-injected catalog data.
@@ -2331,24 +2274,25 @@ declare function createCatalogIntentResolver(options: CatalogIntentResolverOptio
  * resolved manifest without importing `@kehto/nip`.
  */
 interface ManifestArchetypeInput {
-    /** The napplet's `d` identifier. */
-    dTag: string;
+    /** Publisher/kind-safe catalog identifier derived from the verified event. */
+    catalogId: string;
     /** Optional human-readable title from the manifest. */
     title?: string;
     /**
-     * Ordered convention contracts from the manifest's `archetype` tags.
+     * Normalized current z/i combinations or exact legacy archetype pairs.
      */
     archetypes: Array<{
         slug: string;
         convention: string;
+        params: string[];
     }>;
 }
 /**
  * Map a resolved napplet manifest's archetype data into an
  * {@link IntentCatalogEntry}.
  *
- * Repeated slugs group into one support record; action and convention arrays
- * remain stable and deduplicated.
+ * Repeated slugs group into one support record; exact contracts and their
+ * parameter arrays remain stable and deduplicated.
  *
  * @param manifest - A resolved manifest's structural archetype data.
  * @returns The `IntentCatalogEntry` for `createCatalogIntentResolver`.
@@ -2356,15 +2300,14 @@ interface ManifestArchetypeInput {
  * @example
  * ```ts
  * manifestToIntentCatalogEntry({
- *   dTag: 'profile-viewer',
+ *   catalogId: 'nip5d:35129:publisher:profile-viewer',
  *   title: 'Profile',
- *   archetypes: [{ slug: 'profile', convention: 'napplet:profile/open' }],
+ *   archetypes: [{ slug: 'profile', convention: 'napplet:profile/open', params: ['pubkey'] }],
  * });
- * // → { dTag: 'profile-viewer', title: 'Profile',
- * //     archetypes: { profile: {
- * //       actions: ['open'],
- * //       conventions: ['napplet:profile/open'],
- * //     } } }
+ * // → { id: 'nip5d:35129:publisher:profile-viewer', title: 'Profile',
+ * //     archetypes: { profile: { contracts: [
+ * //       { convention: 'napplet:profile/open', params: ['pubkey'] },
+ * //     ] } } }
  * ```
  */
 declare function manifestToIntentCatalogEntry(manifest: ManifestArchetypeInput): IntentCatalogEntry;
@@ -2854,4 +2797,4 @@ interface FsService extends ServiceHandler {
  */
 declare function createFsService(options: FsServiceOptions): FsService;
 
-export { type BleServiceContext, type BleServiceOptions, type CacheServiceOptions, type CatalogIntentResolver, type CatalogIntentResolverOptions, type CommonServiceContext, type CommonServiceOptions, type ConfigSchemaValidation, type ConfigService, type ConfigServiceOptions, type ConfigSettingsContext, type CoordinatedRelayOptions, type CordnCodecResult, type CordnCoordinatorClient, type CordnCoordinatorSubscription, type CordnDmAdapterOptions, type CordnDmClient, type CordnGroupMessage, type CordnRelayCoordinatorOptions, type CountRequest, type CountResult, type CountServiceOptions, type DmAdapter, DmMemoryStore, type DmRelayPool, type DmService, type DmServiceOptions, type FsBackend, type FsBackendChange, type FsBackendWatch, type FsService, FsServiceError, type FsServiceOptions, type HostCacheBridge, type HostKeyEvent, type HostKeysBridge, type HostMediaBridge, type HttpUploaderOptions, type HttpUploaderRails, type IdentityServiceOptions, type IntentArchetypeSupport, type IntentCatalogEntry, type IntentDispatchParams, type IntentResolver, type IntentResolverContext, type IntentServiceOptions, type IntentTargetController, type IntentTargetDispatch, type KeysServiceOptions, type LinkOpenContext, type LinkServiceOptions, type ListsServiceContext, type ListsServiceOptions, type ManifestArchetypeInput, type MaybePromise, type MediaMetadataLike, type MediaPlaybackOwner, type MediaServiceOptions, type MediaSessionCreateOptions, type MediaSessionTarget, type MediaSourceRef, type NdrDmAdapterOptions, type NdrRelayTransport, type NdrRelayTransportOptions, type NdrRumorLike, type NdrRuntimeLike, type Nip17DmAdapterOptions, type NostrTag, type Notification, type NotificationServiceOptions, type NotifyInteractionMessage, type NotifyPresentation, type NotifyServiceOptions, type OutboxEventOptions, type OutboxEventResult, type OutboxPublishOptions, type OutboxPublishResult, type OutboxQueryOptions, type OutboxQueryStream, type OutboxQueryStreamSink, type OutboxRelayPlan, type OutboxRelayPool, type OutboxResult, type OutboxRouter, type OutboxRouterSubscription, type OutboxServiceOptions, type OutboxSubscribeOptions, type OutboxSubscriptionSink, type OutboxTarget, type RailServerConfig, type RelayListEntry, type RelayPoolOutboxRouterOptions, type RelayPoolServiceOptions, type ResourceErrorCode, type ResourceFetchInit, type ResourceInfoContext, type ResourceInfoProvider, type ResourceService, ResourceServiceError, type ResourceServiceOptions, type SerialServiceContext, type SerialServiceOptions, type SignEvent, type StreamingOutboxRouter, type ThemeService, type ThemeServiceOptions, type UploadDimensions, type UploadInfo, type UploadInfoContext, type UploadInfoProvider, type UploadRail, type UploadRailInfo, type UploadRequest, type UploadResult, type UploadServiceOptions, type UploadState, type UploadStatus, type Uploader, type UploaderContext, type WebrtcServiceContext, type WebrtcServiceOptions, createBleService, createBrowserMediaBridge, createCacheService, createCatalogIntentResolver, createCommonService, createConfigService, createCoordinatedRelay, createCordnDmAdapter, createCordnRelayCoordinatorClient, createCountService, createDmService, createFsService, createHttpUploader, createIdentityService, createIntentService, createKeysService, createLinkService, createListsService, createMediaService, createNdrDmAdapter, createNdrRelayTransport, createNip17DmAdapter, createNotificationService, createNotifyService, createOutboxService, createRelayPoolOutboxRouter, createRelayPoolService, createResourceService, createSerialService, createThemeService, createUploadService, createWebrtcService, manifestToIntentCatalogEntry, resolveConfigValues, validateConfigSchema };
+export { type BleServiceContext, type BleServiceOptions, type CacheServiceOptions, type CatalogIntentResolver, type CatalogIntentResolverOptions, type CommonServiceContext, type CommonServiceOptions, type ConfigSchemaValidation, type ConfigService, type ConfigServiceOptions, type ConfigSettingsContext, type CoordinatedRelayOptions, type CordnCodecResult, type CordnCoordinatorClient, type CordnCoordinatorSubscription, type CordnDmAdapterOptions, type CordnDmClient, type CordnGroupMessage, type CordnRelayCoordinatorOptions, type CountRequest, type CountResult, type CountServiceOptions, type DmAdapter, DmMemoryStore, type DmRelayPool, type DmService, type DmServiceOptions, type FsBackend, type FsBackendChange, type FsBackendWatch, type FsService, FsServiceError, type FsServiceOptions, type HostCacheBridge, type HostKeyEvent, type HostKeysBridge, type HostMediaBridge, type HttpUploaderOptions, type HttpUploaderRails, type IdentityServiceOptions, type IntentArchetypeSupport, type IntentAvailability, type IntentBehavior, type IntentCandidate, type IntentCatalogEntry, type IntentContract, type IntentDelivery, type IntentDispatchParams, type IntentHandlerHint, type IntentRequest, type IntentResolver, type IntentResolverContext, type IntentResult, type IntentServiceOptions, type IntentTargetAcceptance, type IntentTargetController, type KeysServiceOptions, type LinkOpenContext, type LinkServiceOptions, type ListsServiceContext, type ListsServiceOptions, type ManifestArchetypeInput, type MaybePromise, type MediaMetadataLike, type MediaPlaybackOwner, type MediaServiceOptions, type MediaSessionCreateOptions, type MediaSessionTarget, type MediaSourceRef, type NdrDmAdapterOptions, type NdrRelayTransport, type NdrRelayTransportOptions, type NdrRumorLike, type NdrRuntimeLike, type Nip17DmAdapterOptions, type NostrTag, type Notification, type NotificationServiceOptions, type NotifyInteractionMessage, type NotifyPresentation, type NotifyServiceOptions, type OutboxEventOptions, type OutboxEventResult, type OutboxPublishOptions, type OutboxPublishResult, type OutboxQueryOptions, type OutboxQueryStream, type OutboxQueryStreamSink, type OutboxRelayPlan, type OutboxRelayPool, type OutboxResult, type OutboxRouter, type OutboxRouterSubscription, type OutboxServiceOptions, type OutboxSubscribeOptions, type OutboxSubscriptionSink, type OutboxTarget, type RailServerConfig, type RelayListEntry, type RelayPoolOutboxRouterOptions, type RelayPoolServiceOptions, type ResourceErrorCode, type ResourceFetchInit, type ResourceInfoContext, type ResourceInfoProvider, type ResourceService, ResourceServiceError, type ResourceServiceOptions, type SerialServiceContext, type SerialServiceOptions, type SignEvent, type StreamingOutboxRouter, type ThemeService, type ThemeServiceOptions, type UploadDimensions, type UploadInfo, type UploadInfoContext, type UploadInfoProvider, type UploadRail, type UploadRailInfo, type UploadRequest, type UploadResult, type UploadServiceOptions, type UploadState, type UploadStatus, type Uploader, type UploaderContext, type WebrtcServiceContext, type WebrtcServiceOptions, createBleService, createBrowserMediaBridge, createCacheService, createCatalogIntentResolver, createCommonService, createConfigService, createCoordinatedRelay, createCordnDmAdapter, createCordnRelayCoordinatorClient, createCountService, createDmService, createFsService, createHttpUploader, createIdentityService, createIntentService, createKeysService, createLinkService, createListsService, createMediaService, createNdrDmAdapter, createNdrRelayTransport, createNip17DmAdapter, createNotificationService, createNotifyService, createOutboxService, createRelayPoolOutboxRouter, createRelayPoolService, createResourceService, createSerialService, createThemeService, createUploadService, createWebrtcService, manifestToIntentCatalogEntry, resolveConfigValues, validateConfigSchema };