@napplet/conformance-cli 0.2.18 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 napplet contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/host-bundle.global.js

@@ -136,7 +136,7 @@ var NappletConformanceHostBundle = (() => {
     // ── resource ─────────────────────────────────────────────────────────────
     "resource.info": { dir: "out", fields: { ...ID } },
     "resource.bytes": { dir: "out", fields: { ...ID, url: "string" } },
-    "resource.bytesMany": { dir: "out", fields: { ...ID, urls: "array" } },
+    "resource.bytesMany": { dir: "out", fields: { ...ID, requests: "array" } },
     "resource.cancel": { dir: "out", fields: { ...ID } },
     "resource.info.result": { dir: "in" },
     "resource.info.error": { dir: "in" },
@@ -185,7 +185,7 @@ var NappletConformanceHostBundle = (() => {
     "intent.invoke": { dir: "out", fields: { ...ID, request: "object" } },
     "intent.available": { dir: "out", fields: { ...ID, archetype: "string" } },
     "intent.handlers": { dir: "out", fields: { ...ID } },
-    "intent.invoke.result": { dir: "in" },
+    "intent.invoke.result": { dir: "in", fields: { ...ID, result: "object" } },
     "intent.available.result": { dir: "in" },
     "intent.handlers.result": { dir: "in" },
     "intent.changed": { dir: "in" },
@@ -336,6 +336,48 @@ var NappletConformanceHostBundle = (() => {
       });
     }
   }
+  function validateServerHints(value, field, errors) {
+    if (Array.isArray(value) && value.every((server) => typeof server === "string")) return;
+    errors.push({
+      code: "wrong-type",
+      message: `Field "${field}" must be an array of strings`,
+      field
+    });
+  }
+  function validateResourceRequestFields(record, errors) {
+    if (record.servers !== void 0) validateServerHints(record.servers, "servers", errors);
+  }
+  function validateResourceBytesManyRequests(requests, errors) {
+    if (!Array.isArray(requests)) return;
+    if (requests.length === 0) {
+      errors.push({
+        code: "invalid-resource-request",
+        message: 'Field "requests" must contain at least one resource request',
+        field: "requests"
+      });
+      return;
+    }
+    for (const [index, request] of requests.entries()) {
+      const field = `requests[${index}]`;
+      if (typeof request !== "object" || request === null || Array.isArray(request)) {
+        errors.push({
+          code: "invalid-resource-request",
+          message: `Field "${field}" must be a resource request object`,
+          field
+        });
+        continue;
+      }
+      const entry = request;
+      if (typeof entry.url !== "string") {
+        errors.push({
+          code: entry.url === void 0 ? "missing-field" : "wrong-type",
+          message: `Field "${field}.url" must be a string`,
+          field: `${field}.url`
+        });
+      }
+      if (entry.servers !== void 0) validateServerHints(entry.servers, `${field}.servers`, errors);
+    }
+  }
   function validateEnvelope(message) {
     const errors = [];
     if (typeof message !== "object" || message === null || Array.isArray(message)) {
@@ -396,6 +438,12 @@ var NappletConformanceHostBundle = (() => {
     if (type === "intent.invoke") {
       validateIntentInvokeRequest(record.request, errors);
     }
+    if (type === "resource.bytes") {
+      validateResourceRequestFields(record, errors);
+    }
+    if (type === "resource.bytesMany") {
+      validateResourceBytesManyRequests(record.requests, errors);
+    }
     return { ok: errors.length === 0, type, domain, direction: "out", errors };
   }
   var NAPPLET_KIND_SNAPSHOT = 5129;
@@ -413,14 +461,14 @@ var NappletConformanceHostBundle = (() => {
     return NAPPLET_MANIFEST_KINDS.includes(kind);
   }
   function isSha256Hex(value) {
-    return typeof value === "string" && /^[0-9a-f]{64}$/i.test(value);
+    return typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
   }
   function manifestDTag(event) {
-    const d = firstTag(event, "d")?.[1]?.trim();
+    const d = firstTag(event, "d")?.[1];
     return d || void 0;
   }
   function manifestRequires(event) {
-    return event.tags.filter((tag) => tag[0] === "requires").map((tag) => tag[1]?.trim() ?? "").filter(Boolean);
+    return event.tags.filter((tag) => tag[0] === "R").map((tag) => tag[1]?.trim() ?? "").filter(Boolean);
   }
   function validateManifestEvent(event) {
     const errors = [];
@@ -429,6 +477,7 @@ var NappletConformanceHostBundle = (() => {
       return {
         ok: false,
         requires: [],
+        optional: [],
         errors: [{ code: "missing-manifest-event", message: "No NIP-5D manifest event was resolved" }],
         warnings
       };
@@ -441,53 +490,58 @@ var NappletConformanceHostBundle = (() => {
         message: `Manifest event kind ${event.kind} is not a NIP-5D napplet kind`
       });
     }
-    if (event.kind === NAPPLET_KIND_NAMED && !dTag) {
-      errors.push({
-        code: "missing-d-tag",
-        message: "Named napplet manifest kind 35129 must include a non-empty d tag"
-      });
-    } else if ((event.kind === NAPPLET_KIND_ROOT || event.kind === NAPPLET_KIND_SNAPSHOT) && dTag) {
-      errors.push({
-        code: "unexpected-d-tag",
-        message: `Napplet manifest kind ${event.kind} must not include a d tag`
-      });
+    const identifiers = event.tags.filter((tag) => tag[0] === "d");
+    if (event.kind === NAPPLET_KIND_NAMED && (identifiers.length !== 1 || !dTag)) {
+      errors.push({ code: "missing-d-tag", message: "Named manifests require exactly one non-empty d tag" });
+    } else if (event.kind !== NAPPLET_KIND_NAMED && identifiers.length > 0) {
+      errors.push({ code: "unexpected-d-tag", message: "Only named manifests carry a d tag" });
     }
-    const indexPath = event.tags.find((tag) => tag[0] === "path" && tag[1] === "/index.html");
-    if (!indexPath) {
-      errors.push({
-        code: "missing-index-html",
-        message: "Napplet manifest must include a path tag for /index.html"
-      });
-    } else if (!isSha256Hex(indexPath[2])) {
-      errors.push({
-        code: "invalid-index-html-hash",
-        message: "The /index.html path tag must carry a 64-character sha256 hash"
-      });
+    const hashes = event.tags.filter((tag) => tag[0] === "x");
+    if (hashes.length !== 1 || hashes[0].length !== 2 || !isSha256Hex(hashes[0][1])) {
+      errors.push({ code: "invalid-artifact-hash", message: "Manifest requires exactly one x tag with the lowercase sha256 of /index.html" });
     }
-    for (const req of requires) {
-      if (req.startsWith("nap:") || req.startsWith("NAP-")) {
-        errors.push({
-          code: "invalid-required-nap",
-          message: `requires tag "${req}" must be a bare NAP domain such as "relay"`
-        });
-        continue;
-      }
-      if (!NAP_DOMAINS.includes(req)) {
-        errors.push({
-          code: "unknown-required-nap",
-          message: `requires tag "${req}" is not a known NAP domain`
-        });
-      }
+    if (typeof event.content !== "string" || !event.content.trim()) {
+      errors.push({ code: "missing-description", message: "Manifest content must contain a non-empty plain-text description" });
     }
+    validateCapabilities(event, errors, warnings);
+    validateMetadata(event, errors, warnings);
     return {
       ok: errors.length === 0,
       kind: event.kind,
       dTag,
       requires,
+      optional: event.tags.filter((tag) => tag[0] === "O").map((tag) => tag[1]).filter(Boolean),
       errors,
       warnings
     };
   }
+  function validateCapabilities(event, errors, warnings) {
+    for (const tag of event.tags.filter((tag2) => tag2[0] === "R" || tag2[0] === "O")) {
+      const domain = tag[1];
+      if (tag.length !== 2 || !domain || /[.:\s]/.test(domain) || domain.startsWith("NAP-")) {
+        errors.push({ code: tag[0] === "R" ? "invalid-required-nap" : "invalid-optional-nap", message: `${tag[0]} must name one bare NAP domain` });
+      } else if (!NAP_DOMAINS.includes(domain)) {
+        warnings.push({ code: "unknown-required-nap", message: `Domain "${domain}" is not in this tool's registry; check its NAP and runtime availability` });
+      }
+    }
+  }
+  function validateMetadata(event, errors, warnings) {
+    for (const name of ["title", "source", "a", "A"]) {
+      const tags = event.tags.filter((tag) => tag[0] === name);
+      if (tags.length > 1 || tags.length && (name === "a" || name === "A") && event.kind !== NAPPLET_KIND_SNAPSHOT) {
+        errors.push({ code: "invalid-metadata", message: `Invalid ${name} tag cardinality for kind ${event.kind}` });
+      }
+    }
+    for (const tag of event.tags.filter((tag2) => tag2[0] === "i")) {
+      if (!tag[1]?.trim() || tag[1].includes("?")) {
+        errors.push({ code: "invalid-metadata", message: "Intent advertisements must be non-empty queryless identities" });
+      }
+    }
+    const icons = event.tags.filter((tag) => tag[0] === "icon");
+    if (icons.length > 1 || icons.some((tag) => tag.length !== 3 || !isSha256Hex(tag[1]) || !["image/png", "image/jpeg", "image/webp"].includes(tag[2]))) {
+      warnings.push({ code: "invalid-icon", message: "Ignore invalid icon metadata and use generic artwork (NIP-5D \xA7Icon)" });
+    }
+  }
   var REFERENCE_PUBKEY = "f".repeat(64);
   var REFERENCE_ENDPOINT = { dTag: "reference-source" };
   var REFERENCE_BLOB_URL = "https://reference.invalid/blob";
@@ -587,10 +641,11 @@ var NappletConformanceHostBundle = (() => {
     "resource.bytesMany": (e) => ok({
       type: "resource.bytesMany.result",
       id: e.id,
-      items: Array.isArray(e.urls) ? e.urls.map((url) => {
+      items: Array.isArray(e.requests) ? e.requests.map((request) => {
+        const url = typeof request === "object" && request !== null && !Array.isArray(request) ? request.url : void 0;
         const decoded = dataUrlToBlob(url);
         return {
-          url,
+          url: typeof url === "string" ? url : "",
           ok: true,
           blob: decoded?.blob ?? new Blob([]),
           mime: decoded?.mime ?? "application/octet-stream"
@@ -604,7 +659,8 @@ var NappletConformanceHostBundle = (() => {
         schemes: [
           { scheme: "data", enabled: true },
           { scheme: "https", enabled: true }
-        ]
+        ],
+        maxServers: 8
       }
     }),
     "resource.cancel": none,
@@ -738,118 +794,133 @@ var NappletConformanceHostBundle = (() => {
     "fs.watch": (e) => ok({ type: "fs.watch.result", id: e.id, watchId: `watch-${String(e.id)}` }),
     "fs.unwatch": (e) => ok({ type: "fs.unwatch.result", id: e.id })
   };
-  function createReferenceShell(options = {}) {
-    const now = options.now ?? (() => Date.now());
-    const records = [];
-    const targetQueues = /* @__PURE__ */ new Map();
-    function queueDelivery(target, delivery) {
-      const queue = targetQueues.get(target);
-      if (queue) {
-        queue.push(delivery);
-        return;
-      }
-      targetQueues.set(target, [delivery]);
-    }
-    function takeDeliveries(target) {
-      const queue = targetQueues.get(target) ?? [];
-      targetQueues.delete(target);
-      return queue;
-    }
-    function unavailableIntent(id, archetype, action, error) {
-      return ok({
-        type: "intent.invoke.result",
-        id,
-        result: { ok: false, archetype, action, handled: false, error }
-      });
-    }
-    function handleIntentInvoke(_endpoint, env) {
-      const request = env.request;
-      if (typeof request !== "object" || request === null || Array.isArray(request)) {
-        return unavailableIntent(env.id, "", "open", "invalid intent request");
-      }
-      const intent = request;
-      const archetype = typeof intent.archetype === "string" ? intent.archetype : "";
-      const action = typeof intent.action === "string" ? intent.action : "open";
-      if (!archetype) {
-        return unavailableIntent(env.id, archetype, action, "intent request requires an archetype");
-      }
-      if (archetype !== "note") {
-        return unavailableIntent(env.id, archetype, action, "no handler");
-      }
-      if (intent.convention !== void 0 && intent.convention !== REFERENCE_CONVENTION) {
-        return unavailableIntent(env.id, archetype, action, "unsupported convention");
-      }
-      return ok({
-        type: "intent.invoke.result",
-        id: env.id,
-        result: {
-          ok: true,
-          archetype,
-          action,
-          handled: true,
-          handler: REFERENCE_HANDLER,
-          windowId: "reference-window",
-          convention: typeof intent.convention === "string" ? intent.convention : REFERENCE_CONVENTION
-        }
-      });
-    }
-    function intentAvailability(archetype) {
-      if (archetype !== "note") {
-        return { archetype, available: false, candidates: [], hasDefault: false };
-      }
-      return {
-        archetype,
-        available: true,
-        candidates: [{
-          dTag: REFERENCE_HANDLER,
-          actions: ["open"],
-          conventions: [REFERENCE_CONVENTION],
-          isDefault: true
-        }],
-        hasDefault: true
-      };
-    }
-    function handleFrom(endpoint, envelope) {
-      const type = envelope && typeof envelope === "object" && typeof envelope.type === "string" ? envelope.type : void 0;
+  function createReferenceHandler(options) {
+    return (endpoint, envelope) => {
+      const type = getEnvelopeType(envelope);
       const verdict = validateEnvelope(envelope);
-      records.push({ envelope, verdict, timestamp: now() });
+      options.records.push({ envelope, verdict, timestamp: options.now() });
       if (!type || !verdict.ok) return [];
       const env = envelope;
-      if (type === "intent.invoke") return handleIntentInvoke(endpoint, env);
+      if (type === "intent.invoke") return options.intents.handleInvoke(endpoint, env);
       if (type === "intent.available") {
-        return ok({ type: "intent.available.result", id: env.id, availability: intentAvailability(env.archetype) });
+        return ok({ type: "intent.available.result", id: env.id, availability: options.intents.availability(env.archetype) });
       }
       if (type === "intent.handlers") {
-        return ok({ type: "intent.handlers.result", id: env.id, handlers: [intentAvailability("note")] });
-      }
-      if (type === "inc.emit") {
-        if (env.topic === REFERENCE_CONVENTION) {
-          const event = {
-            type: "inc.event",
-            topic: env.topic,
-            sender: endpoint.dTag
-          };
-          if ("payload" in env) event.payload = env.payload;
-          queueDelivery(REFERENCE_SUBSCRIBER, event);
-        }
-        return [];
+        return ok({ type: "intent.handlers.result", id: env.id, handlers: [options.intents.availability("note")] });
       }
+      if (type === "inc.emit") return handleIncEmit(endpoint, env, options.queueDelivery);
       const responder = RESPONDERS[type];
       return responder ? responder(env) : [];
+    };
+  }
+  function getEnvelopeType(envelope) {
+    if (!envelope || typeof envelope !== "object") return void 0;
+    const type = envelope.type;
+    return typeof type === "string" ? type : void 0;
+  }
+  function handleIncEmit(endpoint, env, queueDelivery) {
+    if (env.topic !== REFERENCE_CONVENTION) return [];
+    const event = {
+      type: "inc.event",
+      topic: env.topic,
+      sender: endpoint.dTag
+    };
+    if ("payload" in env) event.payload = env.payload;
+    queueDelivery(REFERENCE_SUBSCRIBER, event);
+    return [];
+  }
+  function unavailableIntent(id, archetype, action, error) {
+    return ok({
+      type: "intent.invoke.result",
+      id,
+      result: { ok: false, archetype, action, handled: false, error }
+    });
+  }
+  function createIntentHandlers() {
+    return { handleInvoke, availability };
+  }
+  function handleInvoke(_endpoint, env) {
+    const request = env.request;
+    if (typeof request !== "object" || request === null || Array.isArray(request)) {
+      return unavailableIntent(env.id, "", "open", "invalid intent request");
+    }
+    const intent = request;
+    const archetype = typeof intent.archetype === "string" ? intent.archetype : "";
+    const action = typeof intent.action === "string" ? intent.action : "open";
+    if (!archetype) {
+      return unavailableIntent(env.id, archetype, action, "intent request requires an archetype");
     }
-    function handle(envelope) {
-      return handleFrom(REFERENCE_ENDPOINT, envelope);
+    if (archetype !== "note") return unavailableIntent(env.id, archetype, action, "no handler");
+    if (intent.convention !== void 0 && intent.convention !== REFERENCE_CONVENTION) {
+      return unavailableIntent(env.id, archetype, action, "unsupported convention");
+    }
+    return ok({
+      type: "intent.invoke.result",
+      id: env.id,
+      result: {
+        ok: true,
+        archetype,
+        action,
+        handled: true,
+        handler: REFERENCE_HANDLER,
+        windowId: "reference-window",
+        convention: typeof intent.convention === "string" ? intent.convention : REFERENCE_CONVENTION
+      }
+    });
+  }
+  function availability(archetype) {
+    if (archetype !== "note") {
+      return { archetype, available: false, candidates: [], hasDefault: false };
     }
+    return {
+      archetype,
+      available: true,
+      candidates: [{
+        dTag: REFERENCE_HANDLER,
+        actions: ["open"],
+        conventions: [REFERENCE_CONVENTION],
+        isDefault: true
+      }],
+      hasDefault: true
+    };
+  }
+  function createReferenceShell(options = {}) {
+    const records = [];
+    const deliveries = createDeliveryQueue();
+    const handleFrom = createReferenceHandler({
+      now: options.now ?? Date.now,
+      records,
+      queueDelivery: deliveries.queue,
+      intents: createIntentHandlers()
+    });
     return {
       get records() {
         return records;
       },
-      handle,
+      handle: (envelope) => handleFrom(REFERENCE_ENDPOINT, envelope),
       handleFrom,
-      takeDeliveries,
+      takeDeliveries: deliveries.take,
       reset() {
         records.length = 0;
-        targetQueues.clear();
+        deliveries.clear();
+      }
+    };
+  }
+  function createDeliveryQueue() {
+    const queues = /* @__PURE__ */ new Map();
+    return {
+      queue(target, delivery) {
+        const queue = queues.get(target);
+        if (queue) queue.push(delivery);
+        else queues.set(target, [delivery]);
+      },
+      take(target) {
+        const queue = queues.get(target) ?? [];
+        queues.delete(target);
+        return queue;
+      },
+      clear() {
+        queues.clear();
       }
     };
   }
@@ -902,11 +973,14 @@ var NappletConformanceHostBundle = (() => {
     napplet.resource.info = () =>
       request({ type: 'resource.info' }, 'resource.info.result', 'resource.info.error')
         .then((msg) => msg.info);
-    napplet.resource.bytes = (url) =>
-      request({ type: 'resource.bytes', url: String(url) }, 'resource.bytes.result', 'resource.bytes.error')
+    napplet.resource.bytes = (url, options) => {
+      const message = { type: 'resource.bytes', url: String(url) };
+      if (options && options.servers !== undefined) message.servers = options.servers;
+      return request(message, 'resource.bytes.result', 'resource.bytes.error')
         .then((msg) => msg.blob);
-    napplet.resource.bytesMany = (urls) =>
-      request({ type: 'resource.bytesMany', urls: Array.from(urls || []) }, 'resource.bytesMany.result', 'resource.bytesMany.error')
+    };
+    napplet.resource.bytesMany = (requests) =>
+      request({ type: 'resource.bytesMany', requests: Array.from(requests || []) }, 'resource.bytesMany.result', 'resource.bytesMany.error')
         .then((msg) => msg.items);
     napplet.resource.bytesAsObjectURL = (url) => {
       const handle = { url: '', revoke: () => {} };
@@ -1044,13 +1118,14 @@ var NappletConformanceHostBundle = (() => {
   var skip = (detail) => ({ status: "skip", detail });
   var result = { pass, fail, skip };
   function manifestErrors(ctx, codes) {
-    return validateManifestEvent(ctx.manifestEvent).errors.filter((e) => codes.includes(e.code));
+    const verdict = validateManifestEvent(ctx.manifestEvent);
+    return [...verdict.errors, ...verdict.warnings].filter((e) => codes.includes(e.code));
   }
-  function manifestCheck(id, title, codes) {
+  function manifestCheck(id, title, codes, severity = "error") {
     return {
       id,
       area: "manifest",
-      severity: "error",
+      severity,
       title,
       run: (ctx) => {
         if (!ctx.manifestEvent) return result.skip("No NIP-5D manifest event was resolved");
@@ -1067,13 +1142,18 @@ var NappletConformanceHostBundle = (() => {
       "unexpected-d-tag"
     ]),
     manifestCheck("manifest/index-html", "Manifest declares a hashed /index.html", [
-      "missing-index-html",
-      "invalid-index-html-hash"
+      "invalid-artifact-hash",
+      "missing-description",
+      "invalid-metadata"
     ]),
-    manifestCheck("manifest/requires", "requires tags are bare known NAP domains", [
+    manifestCheck("manifest/requires", "R/O tags name bare NAP domains", [
       "invalid-required-nap",
-      "unknown-required-nap"
+      "invalid-optional-nap"
     ]),
+    // Registry coverage is a tooling advisory, not a protocol requirement.
+    manifestCheck("manifest/requires-known", "R/O domains are in this toolchain registry (advisory)", [
+      "unknown-required-nap"
+    ], "warning"),
     // ── boot ─────────────────────────────────────────────────────────────────────
     {
       id: "boot/sandbox-allow-scripts",