@kehto/services 0.22.0 → 0.23.0

package/dist/index.js

@@ -1339,11 +1339,11 @@ function hasSourceRef(source) {
 }
 function canonicalizeSessionId(state, windowId, preferredSessionId) {
   const trimmed = typeof preferredSessionId === "string" ? preferredSessionId.trim() : "";
-  const hint = trimmed || `session-${++state.sessionCounter}`;
-  if (!state.sessionRegistry.has(hint)) return hint;
+  const hint2 = trimmed || `session-${++state.sessionCounter}`;
+  if (!state.sessionRegistry.has(hint2)) return hint2;
   let next;
   do {
-    next = `${windowId}:${hint}:${++state.sessionCounter}`;
+    next = `${windowId}:${hint2}:${++state.sessionCounter}`;
   } while (state.sessionRegistry.has(next));
   return next;
 }
@@ -2167,14 +2167,14 @@ var ConfigServiceController = class {
     }
   }
   handleOpenSettings(windowId, message, send) {
-    const record = this.schemas.get(windowId);
-    if (!record) {
+    const record2 = this.schemas.get(windowId);
+    if (!record2) {
       sendSchemaError(send, "no-schema", "no configuration schema is registered");
       return;
     }
     let values;
     try {
-      values = resolveConfigValues(record.schema, this.options.getValues(windowId));
+      values = resolveConfigValues(record2.schema, this.options.getValues(windowId));
     } catch (cause) {
       sendSchemaError(
         send,
@@ -2183,9 +2183,9 @@ var ConfigServiceController = class {
       );
       return;
     }
-    const section = message.section && schemaHasSection(record.schema, message.section) ? message.section : void 0;
+    const section = message.section && schemaHasSection(record2.schema, message.section) ? message.section : void 0;
     this.options.openSettings?.(windowId, section, {
-      schema: structuredClone(record.schema),
+      schema: structuredClone(record2.schema),
       values,
       commit: (next) => this.commitValues(windowId, next)
     });
@@ -3711,371 +3711,256 @@ function toErrorMessage3(err2) {
 }
 
 // src/intent-service.ts
-var INTENT_SERVICE_VERSION = "1.0.0";
 var INTENT_DESCRIPTOR = {
   name: "intent",
-  version: INTENT_SERVICE_VERSION,
-  description: "NAP-INTENT archetype intent dispatch \u2014 invoke/available/handlers"
+  version: "1.0.0",
+  description: "NAP-INTENT convention dispatch"
 };
-function toErrorMessage4(err2) {
-  if (err2 instanceof Error) return err2.message;
-  if (typeof err2 === "string") return err2;
-  return "intent request failed";
-}
-function hasOwn(value, key) {
+var CONVENTION = /^napplet:([a-z0-9][a-z0-9-]*)\/([a-z0-9][a-z0-9-]*)$/;
+var HINT_ADDRESS = /^35129:[a-f0-9]{64}:.+$/;
+function own(value, key) {
   return Object.prototype.hasOwnProperty.call(value, key);
 }
-function validateIntentRequest(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return { error: "invalid request" };
-  }
-  const request = value;
-  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" };
-  }
-  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"];
-  if (Object.keys(request).some((key) => !allowedKeys.includes(key))) {
-    return { error: "invoke rejected" };
-  }
-  if (hasOwn(request, "handler") && request.handler !== void 0 && (typeof request.handler !== "string" || request.handler.length === 0)) {
-    return { error: "invoke rejected" };
-  }
-  let behavior;
-  if (hasOwn(request, "behavior") && request.behavior !== void 0) {
-    if (typeof request.behavior !== "object" || request.behavior === null || Array.isArray(request.behavior)) {
-      return { error: "invoke rejected" };
-    }
-    const record = request.behavior;
-    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,
-      ...typeof request.convention === "string" ? { convention: request.convention } : {},
-      ...hasOwn(request, "payload") ? { payload: request.payload } : {},
-      ...typeof request.handler === "string" ? { handler: request.handler } : {},
-      ...behavior === void 0 ? {} : { behavior }
-    }
-  };
-}
-function settleResolverCall(call, send, resultType, id, onValue) {
-  let pending;
-  try {
-    pending = Promise.resolve(call());
-  } catch (error) {
-    send({ type: resultType, id, error: toErrorMessage4(error) });
-    return;
-  }
-  pending.then((value) => send(onValue(value))).catch((error) => send({ type: resultType, id, error: toErrorMessage4(error) }));
-}
-function rejectedResult(request, error) {
-  return {
-    ok: false,
-    archetype: request.archetype,
-    action: request.action ?? "open",
-    handled: false,
-    error
-  };
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function hint(value) {
+  const source = record(value);
+  if (!source || !own(source, "address") || typeof source.address !== "string" || !HINT_ADDRESS.test(source.address)) return void 0;
+  if (Object.keys(source).some((key) => key !== "address" && key !== "relays")) return void 0;
+  if (source.relays !== void 0 && (!Array.isArray(source.relays) || source.relays.some((relay) => typeof relay !== "string"))) return void 0;
+  return Object.freeze({
+    address: source.address,
+    ...source.relays === void 0 ? {} : { relays: Object.freeze([...source.relays]) }
+  });
 }
-function rejectInvoke(send, id, request, error = "invoke rejected") {
-  send({
-    type: "intent.invoke.result",
-    id,
-    result: rejectedResult(request, error)
+function validateRequest(value) {
+  const source = record(value);
+  if (!source || !own(source, "archetype") || !own(source, "action") || !own(source, "convention")) return void 0;
+  if (Object.keys(source).some((key) => !["archetype", "action", "convention", "payload", "handler", "handlerHint", "behavior"].includes(key))) return void 0;
+  if (typeof source.archetype !== "string" || typeof source.action !== "string" || typeof source.convention !== "string") return void 0;
+  const match = CONVENTION.exec(source.convention);
+  if (!match || match[1] !== source.archetype || match[2] !== source.action) return void 0;
+  if (source.handler !== void 0 && (typeof source.handler !== "string" || source.handler.length === 0)) return void 0;
+  const parsedHint = source.handlerHint === void 0 ? void 0 : hint(source.handlerHint);
+  if (source.handlerHint !== void 0 && !parsedHint) return void 0;
+  const rawBehavior = source.behavior === void 0 ? void 0 : record(source.behavior);
+  if (source.behavior !== void 0 && (!rawBehavior || Object.keys(rawBehavior).some((key) => key !== "focus" && key !== "reuse") || rawBehavior.focus !== void 0 && typeof rawBehavior.focus !== "boolean" || rawBehavior.reuse !== void 0 && typeof rawBehavior.reuse !== "boolean")) return void 0;
+  return Object.freeze({
+    archetype: source.archetype,
+    action: source.action,
+    convention: source.convention,
+    ...own(source, "payload") ? { payload: source.payload } : {},
+    ...source.handler === void 0 ? {} : { handler: source.handler },
+    ...parsedHint === void 0 ? {} : { handlerHint: parsedHint },
+    ...rawBehavior === void 0 ? {} : { behavior: Object.freeze({
+      ...rawBehavior.focus === void 0 ? {} : { focus: rawBehavior.focus },
+      ...rawBehavior.reuse === void 0 ? {} : { reuse: rawBehavior.reuse }
+    }) }
   });
 }
+function reject(send, id, error = "invoke rejected") {
+  send({ type: "intent.invoke.result", id, result: { ok: false, error } });
+}
 function createIntentService(options) {
-  if (!options || typeof options.resolver !== "object" || options.resolver === null) {
-    throw new Error("createIntentService: options.resolver is required");
+  if (!options || !options.resolver || typeof options.resolveSender !== "function") {
+    throw new Error("createIntentService: resolver and resolveSender are required");
   }
-  const { resolver } = options;
   let runtimeContext;
-  let unsubscribeChanged;
-  function handleInvoke(windowId, msg, send) {
-    const m = msg;
-    const id = m.id ?? "";
-    const validation = validateIntentRequest(m.request);
-    if ("error" in validation) {
-      const raw = typeof m.request === "object" && m.request !== null ? m.request : {};
-      rejectInvoke(
-        send,
-        id,
-        {
-          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, validation.request);
-      return;
-    }
-    let pending;
+  let unsubscribe;
+  const { resolver, resolveSender } = options;
+  function invoke2(windowId, message, send) {
+    const envelope = message;
+    const id = typeof envelope.id === "string" ? envelope.id : "";
+    const request = validateRequest(envelope.request);
+    let sender;
     try {
-      pending = Promise.resolve(resolver.invoke(validation.request, { sender }));
+      sender = resolveSender(windowId);
     } catch {
-      rejectInvoke(send, id, validation.request);
-      return;
+      return reject(send, id);
     }
-    void pending.then(
-      (result2) => {
-        send({
-          type: "intent.invoke.result",
-          id,
-          result: result2
-        });
-      },
-      () => {
-        rejectInvoke(send, id, validation.request);
-      }
+    if (!request || !sender) return reject(send, id, request ? "invoke rejected" : "invalid convention");
+    void Promise.resolve().then(() => resolver.invoke(request, { sender, sourceWindowId: windowId })).then(
+      (result2) => send({ type: "intent.invoke.result", id, result: result2 }),
+      () => reject(send, id)
     ).catch(() => {
     });
   }
-  function handleAvailable(msg, send) {
-    const m = msg;
-    const id = m.id ?? "";
-    if (typeof m.archetype !== "string" || m.archetype.length === 0) {
+  function availability(message, send) {
+    const envelope = message;
+    const id = typeof envelope.id === "string" ? envelope.id : "";
+    if (typeof envelope.archetype !== "string" || envelope.archetype.length === 0) {
       send({ type: "intent.available.result", id, error: "invalid archetype" });
       return;
     }
-    const archetype = m.archetype;
-    settleResolverCall(
-      () => resolver.available(archetype),
-      send,
-      "intent.available.result",
-      id,
-      (availability) => ({ type: "intent.available.result", id, availability })
-    );
+    const archetype = envelope.archetype;
+    void Promise.resolve().then(() => resolver.available(archetype)).then(
+      (value) => send({ type: "intent.available.result", id, availability: value }),
+      () => send({ type: "intent.available.result", id, error: "catalog unavailable" })
+    ).catch(() => {
+    });
   }
-  function handleHandlers(msg, send) {
-    const m = msg;
-    const id = m.id ?? "";
-    settleResolverCall(
-      () => resolver.handlers(),
-      send,
-      "intent.handlers.result",
-      id,
-      (handlers) => ({ type: "intent.handlers.result", id, handlers })
-    );
+  function handlers(message, send) {
+    const envelope = message;
+    const id = typeof envelope.id === "string" ? envelope.id : "";
+    void Promise.resolve().then(() => resolver.handlers()).then(
+      (value) => send({ type: "intent.handlers.result", id, handlers: value }),
+      () => send({ type: "intent.handlers.result", id, error: "catalog unavailable" })
+    ).catch(() => {
+    });
   }
   return {
     descriptor: INTENT_DESCRIPTOR,
     onRegistered(context) {
-      try {
-        unsubscribeChanged?.();
-      } catch {
-      }
+      unsubscribe?.();
       runtimeContext = context;
-      unsubscribeChanged = resolver.onChanged?.((availability) => {
+      unsubscribe = resolver.onChanged?.((item) => {
         const current = runtimeContext;
         if (!current) return;
-        const message = { type: "intent.changed", availability };
         for (const windowId of current.listWindowIds()) {
-          current.sendToEligibleNapplet(windowId, message);
+          current.sendToEligibleNapplet(windowId, { type: "intent.changed", availability: item });
         }
       });
     },
     onUnregistered() {
-      const unsubscribe = unsubscribeChanged;
-      unsubscribeChanged = void 0;
+      unsubscribe?.();
+      unsubscribe = void 0;
       runtimeContext = void 0;
-      try {
-        unsubscribe?.();
-      } catch {
-      }
     },
     handleMessage(windowId, message, send) {
-      switch (message.type) {
-        case "intent.invoke":
-          handleInvoke(windowId, message, send);
-          return;
-        case "intent.available":
-          handleAvailable(message, send);
-          return;
-        case "intent.handlers":
-          handleHandlers(message, send);
-          return;
-        default:
-          return;
-      }
+      if (message.type === "intent.invoke") return invoke2(windowId, message, send);
+      if (message.type === "intent.available") return availability(message, send);
+      if (message.type === "intent.handlers") return handlers(message, send);
     }
   };
 }
 
 // src/catalog-intent-resolver.ts
-function candidatesFor(catalog, archetype, defaultHandler) {
-  const candidates = [];
-  for (const entry of catalog) {
-    const support = entry.archetypes[archetype];
-    if (!support) continue;
-    candidates.push({
-      dTag: entry.dTag,
-      ...entry.title === void 0 ? {} : { title: entry.title },
-      actions: [...support.actions],
-      conventions: [...support.conventions],
-      ...entry.dTag === defaultHandler ? { isDefault: true } : {}
-    });
-  }
-  return candidates;
+var CONVENTION2 = /^napplet:([a-z0-9][a-z0-9-]*)\/([a-z0-9][a-z0-9-]*)$/;
+function rejected(error) {
+  return { ok: false, error };
+}
+function candidateFor(entry, archetype, defaultId) {
+  const support = entry.archetypes[archetype];
+  if (!support || support.contracts.length === 0) return void 0;
+  const contracts = support.contracts.map((contract) => Object.freeze({
+    convention: contract.convention,
+    params: Object.freeze([...contract.params])
+  }));
+  const conventions = [...new Set(contracts.map((contract) => contract.convention))];
+  const actions = [...new Set(conventions.map((convention) => CONVENTION2.exec(convention)?.[2]).filter((value) => value !== void 0))];
+  if (actions.length === 0) return void 0;
+  return Object.freeze({
+    id: entry.id,
+    ...entry.title === void 0 ? {} : { title: entry.title },
+    actions: Object.freeze(actions),
+    conventions: Object.freeze(conventions),
+    contracts: Object.freeze(contracts),
+    ...entry.id === defaultId ? { isDefault: true } : {}
+  });
 }
-function reject(request, error) {
-  return {
-    ok: false,
-    archetype: request.archetype,
-    action: request.action ?? "open",
-    handled: false,
-    error
-  };
+function candidatesFor(catalog, archetype, defaultId) {
+  return catalog.map((entry) => candidateFor(entry, archetype, defaultId)).filter((candidate) => candidate !== void 0);
 }
-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)
-  };
+function compatibleFor(request, candidates) {
+  return candidates.filter((candidate) => candidate.contracts.some((contract) => contract.convention === request.convention));
 }
-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;
+async function choose(options, request, candidates, sender) {
+  if (!options.chooseHandler) return rejected(request.handler === "choose" ? "user cancelled" : "invoke rejected");
+  const id = await options.chooseHandler(request.archetype, candidates, sender);
+  if (id === void 0) return rejected("user cancelled");
+  return candidates.find((candidate) => candidate.id === id) ?? rejected("invoke rejected");
+}
+async function select(options, request, candidates, context) {
+  const { sender } = context;
+  if (request.handler && request.handler !== "default" && request.handler !== "choose") {
+    const candidate = candidates.find((item) => item.id === request.handler);
+    if (!candidate || !options.authorizeExplicitHandler) return rejected("invoke rejected");
     try {
-      authorized = await options.authorizeExplicitHandler(
-        sender,
-        preference,
-        request,
-        candidate
-      );
+      return await options.authorizeExplicitHandler(sender, request.handler, request, candidate, context) ? candidate : rejected("invoke rejected");
     } catch {
-      return { error: "invoke rejected" };
+      return rejected("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 (request.handler === "choose") return choose(options, request, candidates, sender);
+  const defaultCandidate = candidates.find((candidate) => candidate.isDefault);
+  if (defaultCandidate) return defaultCandidate;
+  if (request.handlerHint && options.resolveHandlerHint) {
+    try {
+      const id = await options.resolveHandlerHint(request.handlerHint, candidates);
+      const candidate = candidates.find((item) => item.id === id);
+      if (candidate) return candidate;
+    } catch {
+    }
   }
-  if (defaultCandidate) return { candidate: defaultCandidate };
-  if (compatible.length === 1) return { candidate: compatible[0] };
-  return chooseCompatible(options, request, compatible, sender);
+  if (candidates.length === 1) return candidates[0];
+  return choose(options, request, candidates, sender);
 }
-async function invokeFromCatalog(options, request, context) {
+async function availabilityFor(options, archetype) {
   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;
+  const defaultId = options.getDefaultHandler?.(archetype);
+  const candidates = candidatesFor(catalog, archetype, defaultId);
+  return Object.freeze({
+    archetype,
+    available: candidates.length > 0,
+    candidates: Object.freeze(candidates),
+    hasDefault: candidates.some((candidate) => candidate.isDefault)
   });
-  if (!convention) return reject(request, "unsupported convention");
+}
+async function invoke(options, request, context) {
+  const match = CONVENTION2.exec(request.convention);
+  if (!match || match[1] !== request.archetype || match[2] !== request.action) return rejected("invalid convention");
+  if (!context.sender) return rejected("invoke rejected");
+  const catalog = await options.loadCatalog();
+  const candidates = candidatesFor(catalog, request.archetype, options.getDefaultHandler?.(request.archetype));
+  if (candidates.length === 0) return rejected("no handler");
+  const compatible = compatibleFor(request, candidates);
+  if (compatible.length === 0) return rejected(candidates.some((candidate) => candidate.actions.includes(request.action)) ? "unsupported convention" : "unsupported action");
+  const selected = await select(options, request, compatible, context);
+  if ("ok" in selected) return selected;
   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,
+    handler: selected.id,
+    sender: context.sender,
     archetype: request.archetype,
-    action,
-    convention,
+    action: request.action,
+    convention: request.convention,
     ...request.payload === void 0 ? {} : { payload: request.payload },
-    ...behavior === void 0 ? {} : { behavior }
+    ...behavior === void 0 ? {} : { behavior },
+    ...context.sourceWindowId === void 0 ? {} : { sourceWindowId: context.sourceWindowId }
   });
-  let target;
   try {
-    target = await options.targets.dispatch(params);
+    const accepted = options.targets.accept(params);
+    if (!accepted || !(accepted.completion instanceof Promise)) return rejected("invoke rejected");
+    void accepted.completion.catch(() => {
+    });
   } catch {
-    return reject(request, "invoke failed");
+    return rejected("invoke rejected");
   }
-  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
-  };
+  return { ok: true, archetype: request.archetype, action: request.action, convention: request.convention, handler: selected.id };
 }
 function createCatalogIntentResolver(options) {
-  if (!options || typeof options.loadCatalog !== "function") {
-    throw new Error("createCatalogIntentResolver: options.loadCatalog is required");
-  }
-  if (!options.targets || typeof options.targets.dispatch !== "function") {
-    throw new Error("createCatalogIntentResolver: options.targets is required");
-  }
+  if (!options || typeof options.loadCatalog !== "function") throw new Error("createCatalogIntentResolver: options.loadCatalog is required");
+  if (!options.targets || typeof options.targets.accept !== "function") throw new Error("createCatalogIntentResolver: options.targets is required");
   const listeners = /* @__PURE__ */ new Set();
-  const availabilityFor = (archetype) => availabilityForCatalog(options, archetype);
-  async function handlers() {
-    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);
-    }
-    return Promise.all([...archetypes].map((archetype) => availabilityFor(archetype)));
-  }
   return {
-    invoke: (request, context) => invokeFromCatalog(options, request, context),
-    available: availabilityFor,
-    handlers,
+    invoke: (request, context) => invoke(options, request, context),
+    available: (archetype) => availabilityFor(options, archetype),
+    async handlers() {
+      const catalog = await options.loadCatalog();
+      const roles = /* @__PURE__ */ new Set();
+      for (const entry of catalog) for (const role of Object.keys(entry.archetypes)) roles.add(role);
+      return Promise.all([...roles].map((role) => availabilityFor(options, role)));
+    },
     onChanged(listener) {
       listeners.add(listener);
       return () => listeners.delete(listener);
     },
     notifyChanged(archetype) {
-      if (listeners.size === 0) return;
-      void availabilityFor(archetype).then((availability) => {
+      void availabilityFor(options, archetype).then((availability) => {
         for (const listener of listeners) listener(availability);
       });
     }
@@ -4091,21 +3976,24 @@ function actionFromConvention(convention) {
   return match[2];
 }
 function manifestToIntentCatalogEntry(manifest) {
-  const archetypes = {};
-  for (const { slug, convention } of manifest.archetypes) {
+  const archetypes = /* @__PURE__ */ Object.create(null);
+  for (const { slug, convention, params } of manifest.archetypes) {
     if (!/^[a-z0-9][a-z0-9-]*$/.test(slug)) {
       throw new TypeError("manifest archetype slug is invalid");
     }
-    const action = actionFromConvention(convention);
+    actionFromConvention(convention);
+    if (!convention.startsWith(`napplet:${slug}/`)) {
+      throw new TypeError("manifest archetype must match its convention role");
+    }
     const support = archetypes[slug] ??= {
-      actions: [],
-      conventions: []
+      contracts: []
     };
-    if (!support.actions.includes(action)) support.actions.push(action);
-    if (!support.conventions.includes(convention)) support.conventions.push(convention);
+    if (!support.contracts.some((contract) => contract.convention === convention)) {
+      support.contracts.push({ convention, params: [...params] });
+    }
   }
   return {
-    dTag: manifest.dTag,
+    id: manifest.catalogId,
     ...manifest.title === void 0 ? {} : { title: manifest.title },
     archetypes
   };
@@ -4153,7 +4041,7 @@ function createCvmService(options) {
     const m = msg;
     const id = m.id ?? "";
     void transport.discover(m.query).then((servers) => send({ type: "cvm.discover.result", id, servers })).catch(
-      (err2) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage5(err2) })
+      (err2) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage4(err2) })
     );
   }
   function handleRequest(windowId, msg, send) {
@@ -4169,7 +4057,7 @@ function createCvmService(options) {
     }
     openSession(windowId, m.server, send);
     void transport.request(m.server, m.message, m.options).then((message) => send({ type: "cvm.request.result", id, message })).catch(
-      (err2) => send({ type: "cvm.request.result", id, error: toErrorMessage5(err2) })
+      (err2) => send({ type: "cvm.request.result", id, error: toErrorMessage4(err2) })
     );
   }
   function handleClose(windowId, msg, send) {
@@ -4180,7 +4068,7 @@ function createCvmService(options) {
       return;
     }
     closeSession(windowId, m.server.pubkey);
-    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err2) => send({ type: "cvm.close.result", id, error: toErrorMessage5(err2) }));
+    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err2) => send({ type: "cvm.close.result", id, error: toErrorMessage4(err2) }));
   }
   return {
     descriptor: CVM_DESCRIPTOR,
@@ -4218,7 +4106,7 @@ function createCvmService(options) {
     }
   };
 }
-function toErrorMessage5(err2) {
+function toErrorMessage4(err2) {
   if (err2 instanceof Error) return err2.message;
   if (typeof err2 === "string") return err2;
   return "cvm request failed";
@@ -4414,15 +4302,15 @@ function createSerialService(options = {}) {
   const currentWindow = (windowId) => {
     const existing = windows.get(windowId);
     if (existing) return existing;
-    const record = {
+    const record2 = {
       connections: /* @__PURE__ */ new Map(),
       pendingConnections: /* @__PURE__ */ new Set()
     };
-    windows.set(windowId, record);
-    return record;
+    windows.set(windowId, record2);
+    return record2;
   };
-  const emit = (windowId, record, connection, send, event) => {
-    if (!connection || windows.get(windowId) !== record || connection.state === "closed") return;
+  const emit = (windowId, record2, connection, send, event) => {
+    if (!connection || windows.get(windowId) !== record2 || connection.state === "closed") return;
     if (connection.state === "opening") {
       connection.bufferedEvents.push(event);
       return;
@@ -4433,8 +4321,8 @@ function createSerialService(options = {}) {
     descriptor: SERIAL_DESCRIPTOR,
     handleMessage(windowId, message, send) {
       const id = message.id ?? "";
-      const record = currentWindow(windowId);
-      const isCurrent = () => windows.get(windowId) === record;
+      const record2 = currentWindow(windowId);
+      const isCurrent = () => windows.get(windowId) === record2;
       const currentSend = (outbound) => {
         if (isCurrent()) send(outbound);
       };
@@ -4445,13 +4333,13 @@ function createSerialService(options = {}) {
         }
         const serialMessage = message;
         const connection = { state: "opening", bufferedEvents: [] };
-        record.pendingConnections.add(connection);
-        const context = createContext(windowId, (event) => emit(windowId, record, connection, currentSend, event));
+        record2.pendingConnections.add(connection);
+        const context = createContext(windowId, (event) => emit(windowId, record2, connection, currentSend, event));
         let pending;
         try {
           pending = Promise.resolve(options.open(serialMessage.request, context));
         } catch (error) {
-          record.pendingConnections.delete(connection);
+          record2.pendingConnections.delete(connection);
           connection.state = "closed";
           currentSend({
             type: "serial.open.result",
@@ -4461,10 +4349,10 @@ function createSerialService(options = {}) {
           return;
         }
         void pending.then((result2) => {
-          record.pendingConnections.delete(connection);
+          record2.pendingConnections.delete(connection);
           if (!isCurrent() || connection.state === "closed") return;
           connection.state = "open";
-          record.connections.set(result2.session.id, connection);
+          record2.connections.set(result2.session.id, connection);
           currentSend({ type: "serial.open.result", id, session: result2.session });
           if (!isCurrent() || connection.state !== "open") return;
           for (const event of connection.bufferedEvents) {
@@ -4473,7 +4361,7 @@ function createSerialService(options = {}) {
           }
           connection.bufferedEvents.length = 0;
         }).catch((error) => {
-          record.pendingConnections.delete(connection);
+          record2.pendingConnections.delete(connection);
           connection.state = "closed";
           currentSend({
             type: "serial.open.result",
@@ -4491,8 +4379,8 @@ function createSerialService(options = {}) {
         const serialMessage = message;
         const context = createContext(windowId, (event) => emit(
           windowId,
-          record,
-          record.connections.get(serialMessage.sessionId),
+          record2,
+          record2.connections.get(serialMessage.sessionId),
           currentSend,
           event
         ));
@@ -4510,14 +4398,14 @@ function createSerialService(options = {}) {
           return;
         }
         const serialMessage = message;
-        const connection = record.connections.get(serialMessage.sessionId);
+        const connection = record2.connections.get(serialMessage.sessionId);
         if (connection) {
           connection.state = "closed";
-          record.connections.delete(serialMessage.sessionId);
+          record2.connections.delete(serialMessage.sessionId);
         }
         const context = createContext(windowId, (event) => emit(
           windowId,
-          record,
+          record2,
           connection,
           currentSend,
           event
@@ -4537,12 +4425,12 @@ function createSerialService(options = {}) {
       });
     },
     onWindowDestroyed(windowId) {
-      const record = windows.get(windowId);
-      if (record) {
-        for (const connection of record.connections.values()) connection.state = "closed";
-        for (const connection of record.pendingConnections) connection.state = "closed";
-        record.connections.clear();
-        record.pendingConnections.clear();
+      const record2 = windows.get(windowId);
+      if (record2) {
+        for (const connection of record2.connections.values()) connection.state = "closed";
+        for (const connection of record2.pendingConnections) connection.state = "closed";
+        record2.connections.clear();
+        record2.pendingConnections.clear();
         windows.delete(windowId);
       }
       options.destroyWindow?.(windowId);
@@ -5611,13 +5499,13 @@ function createCordnRelayCoordinatorClient(options) {
       const cursor = (cursors.get(gid) ?? 0) + 1;
       cursors.set(gid, cursor);
       const at = nowSeconds3();
-      const record = { cursor, gid, msg_64: input.msg_64, at };
+      const record2 = { cursor, gid, msg_64: input.msg_64, at };
       const event = finalizeEvent2(
         {
           kind,
           created_at: at,
           tags: [["g", gid], ["p", ownerPubkey]],
-          content: JSON.stringify(record)
+          content: JSON.stringify(record2)
         },
         options.ownerSecretKey
       );
@@ -5695,8 +5583,8 @@ function createCordnDmAdapter(options) {
       if (options.client) return options.client.messages(query);
       const gid = query.conversationId.startsWith("group:") ? query.conversationId.slice("group:".length) : query.conversationId;
       const fetched = await options.coordinator.FetchGroupMessages({ gid });
-      for (const record of fetched.messages) store.upsertMessage(
-        (options.decodeMessage ?? defaultDecodeMessage)(record, ownerPubkey),
+      for (const record2 of fetched.messages) store.upsertMessage(
+        (options.decodeMessage ?? defaultDecodeMessage)(record2, ownerPubkey),
         [ownerPubkey ?? "", gid]
       );
       return store.messages(query);
@@ -5705,8 +5593,8 @@ function createCordnDmAdapter(options) {
       if (options.client) return options.client.send(request);
       const encoded = (options.encodeMessage ?? ((req, pk) => defaultEncodeMessage(req, pk, options.defaultGroupId)))(request, ownerPubkey);
       const posted = await options.coordinator.PostGroupMessage({ msg_64: encoded.msg_64 });
-      const record = { ...posted, msg_64: encoded.msg_64 };
-      const message = store.upsertMessage((options.decodeMessage ?? defaultDecodeMessage)(record, ownerPubkey), [ownerPubkey ?? "", encoded.gid]);
+      const record2 = { ...posted, msg_64: encoded.msg_64 };
+      const message = store.upsertMessage((options.decodeMessage ?? defaultDecodeMessage)(record2, ownerPubkey), [ownerPubkey ?? "", encoded.gid]);
       return { ok: true, message: { ...message, status: "sent" } };
     },
     async subscribe(request, onMessage) {
@@ -5716,17 +5604,17 @@ function createCordnDmAdapter(options) {
       const gid = conversationId.startsWith("group:") ? conversationId.slice("group:".length) : conversationId;
       const fetched = await options.coordinator.FetchGroupMessages({ gid });
       let after = 0;
-      for (const record of fetched.messages) {
-        after = Math.max(after, record.cursor);
-        const message = store.upsertMessage((options.decodeMessage ?? defaultDecodeMessage)(record, ownerPubkey), [ownerPubkey ?? "", gid]);
+      for (const record2 of fetched.messages) {
+        after = Math.max(after, record2.cursor);
+        const message = store.upsertMessage((options.decodeMessage ?? defaultDecodeMessage)(record2, ownerPubkey), [ownerPubkey ?? "", gid]);
         onMessage(message);
       }
       const subscription = await options.coordinator.SubscribeGroupMessages({ gid, after });
       const subscriptionId = `dm-cordn-${++cordnSubCounter}`;
       live.set(subscriptionId, { abort: () => subscription.abort("dm.unsubscribe"), conversationId });
       void (async () => {
-        for await (const record of subscription.stream) {
-          const message = store.upsertMessage((options.decodeMessage ?? defaultDecodeMessage)(record, ownerPubkey), [ownerPubkey ?? "", gid]);
+        for await (const record2 of subscription.stream) {
+          const message = store.upsertMessage((options.decodeMessage ?? defaultDecodeMessage)(record2, ownerPubkey), [ownerPubkey ?? "", gid]);
           onMessage(message);
         }
       })();