@kehto/paja 0.9.0 → 0.10.0

package/dist/browser-host.js

@@ -262,7 +262,7 @@ function uploadMap(action) {
   return { senderCap: "upload:write", recipientCap: null };
 }
 function intentMap(action) {
-  if (action === "changed" || action === "deliver" || action === "invoke.result" || action === "available.result" || action === "handlers.result") {
+  if (action === "changed" || action === "invoke.result" || action === "available.result" || action === "handlers.result") {
     return { senderCap: null, recipientCap: "intent:read" };
   }
   if (action === "invoke") return { senderCap: "intent:write", recipientCap: null };
@@ -623,7 +623,7 @@ function deserialize2(json) {
   return defaultConfig();
 }
 
-// ../../node_modules/.pnpm/@napplet+core@0.29.0/node_modules/@napplet/core/dist/index.js
+// ../../node_modules/.pnpm/@napplet+core@0.31.0/node_modules/@napplet/core/dist/index.js
 function createDispatch() {
   const handlers = /* @__PURE__ */ new Map();
   function registerNap2(domain, handler) {
@@ -4862,77 +4862,57 @@ function nappletNamespacePrelude(domains) {
     };
   }
   function makeIntent() {
-    const deliveryHandlers = /* @__PURE__ */ new Set();
-    const pendingDeliveries = [];
     const hasOwn2 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-    const normalizeDelivery = (value) => {
-      if (!value || typeof value !== "object" || typeof value.sender !== "string" || typeof value.archetype !== "string" || typeof value.action !== "string" || typeof value.convention !== "string") {
-        return void 0;
+    const normalizeRequest = (value) => {
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError("Intent request must be an object");
       }
-      const delivery = value;
-      return {
-        sender: delivery.sender,
-        archetype: delivery.archetype,
-        action: delivery.action,
-        convention: delivery.convention,
-        ...hasOwn2(delivery, "payload") ? { payload: delivery.payload } : {}
-      };
-    };
-    listen((event) => {
-      if (!isParentMessage(event)) return;
-      const msg = event.data;
-      if (typeof msg !== "object" || msg === null || msg.type !== "intent.deliver") return;
-      const delivery = normalizeDelivery(msg.delivery);
-      if (!delivery) return;
-      if (deliveryHandlers.size === 0) pendingDeliveries.push(delivery);
-      else for (const handler of deliveryHandlers) handler(delivery);
-    });
-    function normalizeIntentUri(uri, explicitPayload, actionMustBe) {
-      if (typeof uri !== "string" || !uri.startsWith("napplet:")) {
-        throw new TypeError("Intent convention URI must start with napplet:");
+      const supplied = value;
+      if (hasOwn2(supplied, "sender")) {
+        throw new TypeError("Intent callers cannot supply sender");
       }
-      if (uri.includes("#")) throw new TypeError("Intent convention URI cannot contain fragments");
-      const normalized = normalizeConventionUri(uri, explicitPayload);
-      const match = /^napplet:([^/?#]+)\/([^/?#]+)$/.exec(normalized.topic);
-      if (!match) throw new TypeError("Intent convention URI must be napplet:<archetype>/<intent>");
-      if (actionMustBe !== void 0 && match[2] !== actionMustBe) {
-        throw new TypeError(`Intent convention URI must use the ${actionMustBe} intent`);
+      const allowed22 = ["archetype", "action", "convention", "payload", "handler", "behavior"];
+      if (Object.keys(supplied).some((field) => !allowed22.includes(field))) {
+        throw new TypeError("Intent request contains unsupported fields");
       }
-      return {
-        archetype: match[1],
-        action: match[2],
-        convention: normalized.topic,
-        ...normalized.payload === void 0 ? {} : { payload: normalized.payload }
-      };
-    }
-    const invoke = (uri, opts, actionMustBe) => {
-      const supplied = opts && typeof opts === "object" ? opts : void 0;
-      const explicitPayload = supplied?.payload !== void 0;
-      const normalized = normalizeIntentUri(uri, explicitPayload, actionMustBe);
-      if (supplied && hasOwn2(supplied, "sender")) {
-        throw new TypeError("Intent callers cannot supply sender");
+      if (typeof supplied.archetype !== "string" || supplied.archetype.length === 0) {
+        throw new TypeError("Intent request requires an archetype");
       }
-      for (const field of ["archetype", "action", "convention"]) {
-        if (supplied && hasOwn2(supplied, field) && supplied[field] !== normalized[field]) {
-          throw new TypeError(`Intent options cannot override URI-derived ${field}`);
-        }
+      const action = supplied.action === void 0 ? "open" : supplied.action;
+      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");
+      }
+      if (supplied.handler !== void 0 && (typeof supplied.handler !== "string" || supplied.handler.length === 0)) {
+        throw new TypeError("Intent handler must be a non-empty string");
       }
       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") || hasOwn2(behavior, "focus") && typeof behavior.focus !== "boolean" || hasOwn2(behavior, "newWindow") && typeof behavior.newWindow !== "boolean" || hasOwn2(behavior, "reuse") && typeof behavior.reuse !== "boolean")) {
+        throw new TypeError("Intent behavior contains unsupported fields");
+      }
       const sanitizedBehavior = {
         ...typeof behavior?.focus === "boolean" ? { focus: behavior.focus } : {},
+        ...typeof behavior?.newWindow === "boolean" ? { newWindow: behavior.newWindow } : {},
         ...typeof behavior?.reuse === "boolean" ? { reuse: behavior.reuse } : {}
       };
-      const handler = typeof supplied?.handler === "string" ? supplied.handler : void 0;
+      return {
+        archetype: supplied.archetype,
+        action,
+        ...typeof supplied.convention === "string" ? { convention: supplied.convention } : {},
+        ...hasOwn2(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,
-            ...explicitPayload ? { payload: supplied?.payload } : {},
-            ...handler === void 0 ? {} : { handler },
-            ...Object.keys(sanitizedBehavior).length === 0 ? {} : { behavior: sanitizedBehavior }
-          }
+          request: normalized
         },
         "intent.invoke.result",
         (msg) => fieldOrThrow(msg, "result", "intent.invoke.result missing result")
@@ -4940,7 +4920,12 @@ function nappletNamespacePrelude(domains) {
     };
     return {
       invoke,
-      open: (uri, opts) => invoke(uri, opts, "open"),
+      open: (archetype, payload, opts) => invoke({
+        archetype,
+        action: "open",
+        ...payload === void 0 ? {} : { payload },
+        ...opts
+      }),
       available: (archetype) => request(
         { type: "intent.available", archetype },
         "intent.available.result",
@@ -4955,14 +4940,7 @@ function nappletNamespacePrelude(domains) {
         "intent.changed",
         callback,
         (msg) => msg.availability
-      ),
-      onDelivery: (callback) => {
-        if (typeof callback !== "function") throw new TypeError("Intent delivery handler must be a function");
-        deliveryHandlers.add(callback);
-        const pending = pendingDeliveries.splice(0);
-        for (const delivery of pending) callback(delivery);
-        return subscriptionHandle(() => deliveryHandlers.delete(callback));
-      }
+      )
     };
   }
   function makeWebrtc() {
@@ -11721,14 +11699,17 @@ function hasOwn(value, key) {
 }
 function validateIntentRequest(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return { error: "invalid convention" };
+    return { error: "invalid request" };
   }
   const request = value;
-  if (typeof request.archetype !== "string" || request.archetype.length === 0 || typeof request.action !== "string" || request.action.length === 0 || typeof request.convention !== "string" || request.convention.length === 0) {
-    return { error: "invalid convention" };
+  if (typeof request.archetype !== "string" || request.archetype.length === 0) {
+    return { error: "invalid request" };
+  }
+  const action = request.action === void 0 ? "open" : request.action;
+  if (typeof action !== "string" || action.length === 0) {
+    return { error: "invalid request" };
   }
-  const match = /^napplet:([^/?#\s]+)\/([^/?#\s]+)$/.exec(request.convention);
-  if (!match || match[1] !== request.archetype || match[2] !== request.action) {
+  if (request.convention !== void 0 && (typeof request.convention !== "string" || !/^napplet:[^/?#\s]+\/[^/?#\s]+$/.test(request.convention))) {
     return { error: "invalid convention" };
   }
   const allowedKeys = ["archetype", "action", "convention", "payload", "handler", "behavior"];
@@ -11744,19 +11725,20 @@ function validateIntentRequest(value) {
       return { error: "invoke rejected" };
     }
     const record = request.behavior;
-    if (Object.keys(record).some((key) => key !== "focus" && key !== "reuse") || hasOwn(record, "focus") && typeof record.focus !== "boolean" || hasOwn(record, "reuse") && typeof record.reuse !== "boolean") {
+    if (Object.keys(record).some((key) => key !== "focus" && key !== "newWindow" && key !== "reuse") || hasOwn(record, "focus") && typeof record.focus !== "boolean" || hasOwn(record, "newWindow") && typeof record.newWindow !== "boolean" || hasOwn(record, "reuse") && typeof record.reuse !== "boolean") {
       return { error: "invoke rejected" };
     }
     behavior = {
       ...record.focus === void 0 ? {} : { focus: record.focus },
+      ...record.newWindow === void 0 ? {} : { newWindow: record.newWindow },
       ...record.reuse === void 0 ? {} : { reuse: record.reuse }
     };
   }
   return {
     request: {
       archetype: request.archetype,
-      action: request.action,
-      convention: request.convention,
+      action,
+      ...typeof request.convention === "string" ? { convention: request.convention } : {},
       ...hasOwn(request, "payload") ? { payload: request.payload } : {},
       ...typeof request.handler === "string" ? { handler: request.handler } : {},
       ...behavior === void 0 ? {} : { behavior }
@@ -11773,11 +11755,20 @@ function settleResolverCall(call, send, resultType, id, onValue) {
   }
   pending.then((value) => send(onValue(value))).catch((error) => send({ type: resultType, id, error: toErrorMessage4(error) }));
 }
-function rejectInvoke(send, id) {
+function rejectedResult(request, error) {
+  return {
+    ok: false,
+    archetype: request.archetype,
+    action: request.action ?? "open",
+    handled: false,
+    error
+  };
+}
+function rejectInvoke(send, id, request, error = "invoke rejected") {
   send({
     type: "intent.invoke.result",
     id,
-    result: { ok: false, error: "invoke rejected" }
+    result: rejectedResult(request, error)
   });
 }
 function createIntentService(options) {
@@ -11792,46 +11783,40 @@ function createIntentService(options) {
     const id = m.id ?? "";
     const validation = validateIntentRequest(m.request);
     if ("error" in validation) {
-      send({
-        type: "intent.invoke.result",
+      const raw = typeof m.request === "object" && m.request !== null ? m.request : {};
+      rejectInvoke(
+        send,
         id,
-        result: { ok: false, error: validation.error }
-      });
+        {
+          archetype: typeof raw.archetype === "string" ? raw.archetype : "",
+          action: typeof raw.action === "string" ? raw.action : "open"
+        },
+        validation.error
+      );
       return;
     }
     const sender = runtimeContext?.resolveDTag(windowId);
     if (!sender) {
-      rejectInvoke(send, id);
+      rejectInvoke(send, id, validation.request);
       return;
     }
     let pending;
     try {
       pending = Promise.resolve(resolver.invoke(validation.request, { sender }));
     } catch {
-      rejectInvoke(send, id);
+      rejectInvoke(send, id, validation.request);
       return;
     }
     void pending.then(
-      (outcome) => {
-        if (outcome.result.ok && (!("retained" in outcome) || typeof outcome.retained.start !== "function")) {
-          rejectInvoke(send, id);
-          return;
-        }
+      (result2) => {
         send({
           type: "intent.invoke.result",
           id,
-          result: outcome.result
+          result: result2
         });
-        if (!outcome.result.ok || !("retained" in outcome)) return;
-        try {
-          const started = outcome.retained.start();
-          void Promise.resolve(started).catch(() => {
-          });
-        } catch {
-        }
       },
       () => {
-        rejectInvoke(send, id);
+        rejectInvoke(send, id, validation.request);
       }
     ).catch(() => {
     });
@@ -11916,128 +11901,134 @@ function candidatesFor(catalog, archetype, defaultHandler) {
       ...entry.title === void 0 ? {} : { title: entry.title },
       actions: [...support.actions],
       conventions: [...support.conventions],
-      contracts: support.contracts.map((contract) => ({
-        convention: contract.convention,
-        ...contract.eventKinds === void 0 ? {} : { eventKinds: [...contract.eventKinds] }
-      })),
       ...entry.dTag === defaultHandler ? { isDefault: true } : {}
     });
   }
   return candidates;
 }
-function reject(error) {
-  return { ok: false, error };
+function reject(request, error) {
+  return {
+    ok: false,
+    archetype: request.archetype,
+    action: request.action ?? "open",
+    handled: false,
+    error
+  };
+}
+async function availabilityForCatalog(options, archetype) {
+  const catalog = await options.loadCatalog();
+  const defaultHandler = options.getDefaultHandler?.(archetype);
+  const candidates = candidatesFor(catalog, archetype, defaultHandler);
+  return {
+    archetype,
+    available: candidates.length > 0,
+    candidates,
+    hasDefault: defaultHandler !== void 0 && candidates.some((candidate) => candidate.dTag === defaultHandler)
+  };
+}
+async function chooseCompatible(options, request, candidates, sender) {
+  if (!options.chooseHandler) {
+    return request.handler === "choose" ? { error: "user cancelled" } : { error: "invoke rejected" };
+  }
+  const picked = await options.chooseHandler(request.archetype, candidates, sender);
+  if (picked === void 0) return { error: "user cancelled" };
+  const candidate = candidates.find((item) => item.dTag === picked);
+  return candidate ? { candidate } : { error: "invoke rejected" };
+}
+async function pickHandler(options, request, compatible, sender) {
+  const preference = request.handler;
+  if (typeof preference === "string" && preference !== "default" && preference !== "choose") {
+    const candidate = compatible.find((item) => item.dTag === preference);
+    if (!candidate || !options.authorizeExplicitHandler) return { error: "invoke rejected" };
+    let authorized = false;
+    try {
+      authorized = await options.authorizeExplicitHandler(
+        sender,
+        preference,
+        request,
+        candidate
+      );
+    } catch {
+      return { error: "invoke rejected" };
+    }
+    return authorized ? { candidate } : { error: "invoke rejected" };
+  }
+  if (preference === "choose") {
+    return chooseCompatible(options, request, compatible, sender);
+  }
+  const defaultCandidate = compatible.find((candidate) => candidate.isDefault === true);
+  if (preference === "default") {
+    return defaultCandidate ? { candidate: defaultCandidate } : { error: "invoke rejected" };
+  }
+  if (defaultCandidate) return { candidate: defaultCandidate };
+  if (compatible.length === 1) return { candidate: compatible[0] };
+  return chooseCompatible(options, request, compatible, sender);
+}
+async function invokeFromCatalog(options, request, context) {
+  const catalog = await options.loadCatalog();
+  const defaultHandler = options.getDefaultHandler?.(request.archetype);
+  const candidates = candidatesFor(catalog, request.archetype, defaultHandler);
+  if (candidates.length === 0) return reject(request, "no handler");
+  const action = request.action ?? "open";
+  const actionCompatible = candidates.filter((candidate) => candidate.actions.includes(action));
+  if (actionCompatible.length === 0) return reject(request, "unsupported action");
+  const compatible = request.convention === void 0 ? actionCompatible : actionCompatible.filter((candidate) => candidate.conventions.includes(request.convention));
+  if (compatible.length === 0) return reject(request, "unsupported convention");
+  const sender = context.sender;
+  if (typeof sender !== "string" || sender.length === 0) {
+    return reject(request, "invoke rejected");
+  }
+  const selected = await pickHandler(options, request, compatible, sender);
+  if ("error" in selected) return reject(request, selected.error);
+  const convention = request.convention ?? selected.candidate.conventions.find((value) => {
+    const match = /^napplet:[^/?#\s]+\/([^/?#\s]+)$/.exec(value);
+    return match?.[1] === action;
+  });
+  if (!convention) return reject(request, "unsupported convention");
+  const behavior = request.behavior === void 0 ? void 0 : Object.freeze({
+    ...request.behavior.focus === void 0 ? {} : { focus: request.behavior.focus },
+    ...request.behavior.newWindow === void 0 ? {} : { newWindow: request.behavior.newWindow },
+    ...request.behavior.reuse === void 0 ? {} : { reuse: request.behavior.reuse }
+  });
+  const params = Object.freeze({
+    handler: selected.candidate.dTag,
+    sender,
+    archetype: request.archetype,
+    action,
+    convention,
+    ...request.payload === void 0 ? {} : { payload: request.payload },
+    ...behavior === void 0 ? {} : { behavior }
+  });
+  let target;
+  try {
+    target = await options.targets.dispatch(params);
+  } catch {
+    return reject(request, "invoke failed");
+  }
+  if (!target || typeof target.windowId !== "string" || target.windowId.length === 0) {
+    return reject(request, "invoke failed");
+  }
+  return {
+    ok: true,
+    archetype: request.archetype,
+    action,
+    handled: true,
+    handler: selected.candidate.dTag,
+    windowId: target.windowId,
+    convention
+  };
 }
 function createCatalogIntentResolver(options) {
   if (!options || typeof options.loadCatalog !== "function") {
     throw new Error("createCatalogIntentResolver: options.loadCatalog is required");
   }
-  if (!options.targets || typeof options.targets.retain !== "function") {
+  if (!options.targets || typeof options.targets.dispatch !== "function") {
     throw new Error("createCatalogIntentResolver: options.targets is required");
   }
-  const {
-    loadCatalog,
-    targets,
-    getDefaultHandler,
-    chooseHandler,
-    authorizeExplicitHandler
-  } = options;
   const listeners = /* @__PURE__ */ new Set();
-  async function availabilityFor(archetype) {
-    const catalog = await loadCatalog();
-    const defaultHandler = getDefaultHandler?.(archetype);
-    const candidates = candidatesFor(catalog, archetype, defaultHandler);
-    return {
-      archetype,
-      available: candidates.length > 0,
-      candidates,
-      hasDefault: defaultHandler !== void 0 && candidates.some((candidate) => candidate.dTag === defaultHandler)
-    };
-  }
-  async function chooseCompatible(request, candidates, sender) {
-    if (!chooseHandler) {
-      return request.handler === "choose" ? { error: "user cancelled" } : { error: "invoke rejected" };
-    }
-    const picked = await chooseHandler(request.archetype, candidates, sender);
-    if (picked === void 0) return { error: "user cancelled" };
-    const candidate = candidates.find((item) => item.dTag === picked);
-    return candidate ? { candidate } : { error: "invoke rejected" };
-  }
-  async function pickHandler(request, compatible, sender) {
-    const preference = request.handler;
-    if (typeof preference === "string" && preference !== "default" && preference !== "choose") {
-      const candidate = compatible.find((item) => item.dTag === preference);
-      if (!candidate || !authorizeExplicitHandler) return { error: "invoke rejected" };
-      let authorized = false;
-      try {
-        authorized = await authorizeExplicitHandler(sender, preference, request, candidate);
-      } catch {
-        return { error: "invoke rejected" };
-      }
-      return authorized ? { candidate } : { error: "invoke rejected" };
-    }
-    if (preference === "choose") {
-      return chooseCompatible(request, compatible, sender);
-    }
-    const defaultCandidate = compatible.find((candidate) => candidate.isDefault === true);
-    if (preference === "default") {
-      return defaultCandidate ? { candidate: defaultCandidate } : { error: "invoke rejected" };
-    }
-    if (defaultCandidate) return { candidate: defaultCandidate };
-    if (compatible.length === 1) return { candidate: compatible[0] };
-    return chooseCompatible(request, compatible, sender);
-  }
-  async function invoke(request, context) {
-    const catalog = await loadCatalog();
-    const defaultHandler = getDefaultHandler?.(request.archetype);
-    const candidates = candidatesFor(catalog, request.archetype, defaultHandler);
-    if (candidates.length === 0) return { result: reject("no handler") };
-    const compatible = candidates.filter((candidate) => candidate.contracts.some((contract) => contract.convention === request.convention));
-    if (compatible.length === 0) return { result: reject("unsupported convention") };
-    const sender = context.sender;
-    if (typeof sender !== "string" || sender.length === 0) {
-      return { result: reject("invoke rejected") };
-    }
-    const selected = await pickHandler(request, compatible, sender);
-    if ("error" in selected) return { result: reject(selected.error) };
-    const delivery = Object.freeze({
-      sender,
-      archetype: request.archetype,
-      action: request.action,
-      convention: request.convention,
-      ...request.payload === void 0 ? {} : { payload: request.payload }
-    });
-    const behavior = request.behavior === void 0 ? void 0 : Object.freeze({
-      ...request.behavior.focus === void 0 ? {} : { focus: request.behavior.focus },
-      ...request.behavior.reuse === void 0 ? {} : { reuse: request.behavior.reuse }
-    });
-    const params = Object.freeze({
-      handler: selected.candidate.dTag,
-      delivery,
-      ...behavior === void 0 ? {} : { behavior }
-    });
-    let retained;
-    try {
-      retained = await targets.retain(params);
-    } catch {
-      return { result: reject("invoke rejected") };
-    }
-    if (!retained || typeof retained.start !== "function") {
-      return { result: reject("invoke rejected") };
-    }
-    return {
-      result: {
-        ok: true,
-        archetype: request.archetype,
-        action: request.action,
-        convention: request.convention,
-        handler: selected.candidate.dTag
-      },
-      retained
-    };
-  }
+  const availabilityFor = (archetype) => availabilityForCatalog(options, archetype);
   async function handlers() {
-    const catalog = await loadCatalog();
+    const catalog = await options.loadCatalog();
     const archetypes = /* @__PURE__ */ new Set();
     for (const entry of catalog) {
       for (const slug of Object.keys(entry.archetypes)) archetypes.add(slug);
@@ -12045,7 +12036,7 @@ function createCatalogIntentResolver(options) {
     return Promise.all([...archetypes].map((archetype) => availabilityFor(archetype)));
   }
   return {
-    invoke,
+    invoke: (request, context) => invokeFromCatalog(options, request, context),
     available: availabilityFor,
     handlers,
     onChanged(listener) {
@@ -12072,21 +12063,12 @@ function actionFromConvention(slug, convention) {
 }
 function manifestToIntentCatalogEntry(manifest) {
   const archetypes = {};
-  for (const { slug, convention, eventKinds } of manifest.archetypes) {
+  for (const { slug, convention } of manifest.archetypes) {
     const action = actionFromConvention(slug, convention);
-    if (eventKinds?.some((kind) => !Number.isSafeInteger(kind) || kind < 0)) {
-      throw new TypeError("manifest archetype event kinds must be unsigned safe integers");
-    }
     const support = archetypes[slug] ??= {
       actions: [],
-      conventions: [],
-      contracts: []
+      conventions: []
     };
-    const contract = {
-      convention,
-      ...eventKinds === void 0 || eventKinds.length === 0 ? {} : { eventKinds: [...eventKinds] }
-    };
-    support.contracts.push(contract);
     if (!support.actions.includes(action)) support.actions.push(action);
     if (!support.conventions.includes(convention)) support.conventions.push(convention);
   }
@@ -13095,25 +13077,13 @@ var BrowserIntentController = class {
   }
   options;
   maxAttempts;
-  retain(params) {
-    const retained = freezeRetention(params);
-    let started;
-    let delivered = false;
-    return {
-      start: () => {
-        started ??= this.start(retained, () => delivered, () => {
-          delivered = true;
-        });
-        return started;
-      }
-    };
-  }
-  async start(params, isDelivered, markDelivered) {
+  async dispatch(params) {
+    const dispatch2 = freezeDispatch(params);
     let reason = "no-current-target";
     for (let attempt = 1; attempt <= this.maxAttempts; attempt += 1) {
       let generation;
       try {
-        generation = await this.options.openOrReuse(params, attempt);
+        generation = await this.options.openOrReuse(dispatch2, attempt);
       } catch {
         reason = "open-failed";
         continue;
@@ -13132,17 +13102,18 @@ var BrowserIntentController = class {
         reason = "no-current-target";
         continue;
       }
-      if (isDelivered()) return;
-      markDelivered();
       try {
-        await this.options.send(generation, params.delivery);
-        return;
+        await this.options.send(generation, dispatch2);
+        const windowId = this.options.getWindowId(generation);
+        if (!windowId) throw new Error("intent target window is unavailable");
+        return { windowId };
       } catch {
-        this.options.onTerminal?.(params, "send-failed");
-        return;
+        this.options.onTerminal?.(dispatch2, "send-failed");
+        throw new Error("intent target send failed");
       }
     }
-    this.options.onTerminal?.(params, reason);
+    this.options.onTerminal?.(dispatch2, reason);
+    throw new Error(`intent target ${reason}`);
   }
 };
 function normalizeAttempts(value) {
@@ -13150,15 +13121,22 @@ function normalizeAttempts(value) {
   if (!Number.isFinite(value)) throw new TypeError("maxAttempts must be finite");
   return Math.min(MAX_INTENT_DELIVERY_ATTEMPTS, Math.max(1, Math.floor(value)));
 }
-function freezeRetention(params) {
+function freezeDispatch(params) {
   if (!params || typeof params.handler !== "string" || params.handler.length === 0) {
-    throw new TypeError("Intent retention requires a handler");
+    throw new TypeError("Intent dispatch requires a handler");
+  }
+  if (typeof params.sender !== "string" || params.sender.length === 0 || typeof params.archetype !== "string" || params.archetype.length === 0 || typeof params.action !== "string" || params.action.length === 0 || typeof params.convention !== "string" || params.convention.length === 0) {
+    throw new TypeError("Intent dispatch requires canonical routing fields");
   }
-  const delivery = freezeValue({ ...params.delivery });
+  const payload = freezeValue(params.payload);
   const behavior = params.behavior === void 0 ? void 0 : freezeValue({ ...params.behavior });
   return Object.freeze({
     handler: params.handler,
-    delivery,
+    sender: params.sender,
+    archetype: params.archetype,
+    action: params.action,
+    convention: params.convention,
+    ...params.payload === void 0 ? {} : { payload },
     ...behavior === void 0 ? {} : { behavior }
   });
 }
@@ -13192,10 +13170,10 @@ var InstalledNappletCatalog = class {
       aggregateHash: resolved.aggregateHash,
       pointer: copyPointer(resolved.pointer),
       ...resolved.manifest.title === void 0 ? {} : { title: resolved.manifest.title },
+      requires: [...resolved.manifest.requires],
       archetypes: resolved.manifest.archetypes.map((archetype) => ({
         slug: archetype.slug,
-        convention: archetype.convention,
-        ...archetype.eventKinds === void 0 ? {} : { eventKinds: [...archetype.eventKinds] }
+        convention: archetype.convention
       }))
     });
     this.records.set(record.dTag, record);
@@ -13231,13 +13209,12 @@ var InstalledNappletCatalog = class {
   }
   /** Return exact handler candidates derived only from installed manifests. */
   intentCatalog() {
-    return this.installed().map((record) => manifestToIntentCatalogEntry({
+    return this.installed().filter((record) => record.requires.includes("inc")).map((record) => manifestToIntentCatalogEntry({
       dTag: record.dTag,
       ...record.title === void 0 ? {} : { title: record.title },
       archetypes: record.archetypes.map((archetype) => ({
         slug: archetype.slug,
-        convention: archetype.convention,
-        ...archetype.eventKinds === void 0 ? {} : { eventKinds: [...archetype.eventKinds] }
+        convention: archetype.convention
       }))
     }));
   }
@@ -13273,10 +13250,8 @@ function copyPointer(pointer) {
 function freezeRecord(record) {
   return Object.freeze({
     ...record,
-    archetypes: Object.freeze(record.archetypes.map((archetype) => Object.freeze({
-      ...archetype,
-      ...archetype.eventKinds === void 0 ? {} : { eventKinds: Object.freeze([...archetype.eventKinds]) }
-    })))
+    requires: Object.freeze([...record.requires]),
+    archetypes: Object.freeze(record.archetypes.map((archetype) => Object.freeze({ ...archetype })))
   });
 }
 
@@ -14898,6 +14873,7 @@ function createDefaultIntentHost() {
       openOrReuse: () => null,
       waitForReady: () => void 0,
       isCurrent: () => false,
+      getWindowId: () => null,
       send: () => void 0
     })
   };
@@ -18925,7 +18901,7 @@ function aggregateTagValue(tags) {
   return void 0;
 }
 
-// ../nip/dist/chunk-AGRSQG35.js
+// ../nip/dist/chunk-ZQSTY6HR.js
 var MIB = 1024 * 1024;
 var NAPPLET_ARTIFACT_CACHE_NAME = "kehto:napplet-artifacts:v1";
 var SCHEMA_VERSION = 1;
@@ -19390,28 +19366,13 @@ function archetypesFromTags(tags) {
         "archetype slug must match the convention archetype"
       );
     }
-    const eventKinds = tag.slice(3).map((value) => {
-      const match = /^kind:(\d+)$/.exec(value);
-      if (!match) {
-        throw new NappletResolutionError(
-          "invalid-manifest",
-          "archetype trailing fields must use kind:<unsigned-integer>"
-        );
-      }
-      const kind = Number(match[1]);
-      if (!Number.isSafeInteger(kind) || kind < 0) {
-        throw new NappletResolutionError(
-          "invalid-manifest",
-          "archetype event kinds must be unsigned safe integers"
-        );
-      }
-      return kind;
-    });
-    out.push({
-      slug,
-      convention,
-      ...eventKinds.length === 0 ? {} : { eventKinds }
-    });
+    if (tag.length !== 3) {
+      throw new NappletResolutionError(
+        "invalid-manifest",
+        "archetype tags must contain exactly slug and convention"
+      );
+    }
+    out.push({ slug, convention });
   }
   return out;
 }
@@ -19773,7 +19734,7 @@ function createPajaIntentTargetOptions(getState, getContext, effects = {}) {
       const current = state.tabs.find(
         (tab2) => matchesInstalledNappletRecord(record, tab2.resolvedTarget) && isCurrentRuntimeTabGeneration(state, context, tab2)
       );
-      if (current && params.behavior?.reuse !== false) {
+      if (current && params.behavior?.newWindow !== true && params.behavior?.reuse !== false) {
         return bindPajaIntentGeneration(current, record, context.runtime);
       }
       const resolved = await resolvePajaPointer(record.pointer.value, pajaPointerResolverOptions(context));
@@ -19810,7 +19771,12 @@ function createPajaIntentTargetOptions(getState, getContext, effects = {}) {
       }
       return true;
     },
-    send(generation, delivery) {
+    getWindowId(generation) {
+      const state = getState();
+      const tab = state ? findRuntimeTabGeneration(state, generation) : null;
+      return tab?.windowId ?? null;
+    },
+    send(generation, params) {
       const state = getState();
       const context = getContext();
       const tab = state && context ? findRuntimeTabGeneration(state, generation) : null;
@@ -19823,8 +19789,10 @@ function createPajaIntentTargetOptions(getState, getContext, effects = {}) {
         throw new Error("intent target source is no longer registered");
       }
       createPajaPostMessageProxy(source, state, tab.windowId).postMessage({
-        type: "intent.deliver",
-        delivery
+        type: "inc.event",
+        topic: params.convention,
+        sender: params.sender,
+        ...params.payload === void 0 ? {} : { payload: params.payload }
       }, "*");
     }
   };
@@ -19841,12 +19809,12 @@ function pajaPointerResolverOptions(context) {
 }
 function recordSupportsDelivery(record, params) {
   return record.archetypes.some(
-    (archetype) => archetype.slug === params.delivery.archetype && archetype.convention === params.delivery.convention
+    (archetype) => archetype.slug === params.archetype && archetype.convention === params.convention
   );
 }
 function resolvedSupportsDelivery(resolved, params) {
   return resolved.manifest.archetypes.some(
-    (archetype) => archetype.slug === params.delivery.archetype && archetype.convention === params.delivery.convention
+    (archetype) => archetype.slug === params.archetype && archetype.convention === params.convention
   );
 }
 function findRuntimeTabGeneration(state, generation) {