@kehto/services 0.17.0 → 0.18.0

package/dist/index.js

@@ -3171,14 +3171,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"];
@@ -3194,19 +3197,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 }
@@ -3223,11 +3227,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) {
@@ -3242,46 +3255,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(() => {
     });
@@ -3368,128 +3375,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);
@@ -3497,7 +3510,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) {
@@ -3526,21 +3539,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: []
-    };
-    const contract = {
-      convention,
-      ...eventKinds === void 0 || eventKinds.length === 0 ? {} : { eventKinds: [...eventKinds] }
+      conventions: []
     };
-    support.contracts.push(contract);
     if (!support.actions.includes(action)) support.actions.push(action);
     if (!support.conventions.includes(convention)) support.conventions.push(convention);
   }