@napplet/conformance-cli 0.4.1 → 0.4.3

package/dist/host-bundle.global.js

@@ -2,6 +2,197 @@
 var NappletConformanceHostBundle = (() => {
   // ../core/dist/index.js
   var NAP_DOMAINS = ["shell", "relay", "identity", "storage", "inc", "theme", "keys", "media", "notify", "config", "resource", "cvm", "outbox", "upload", "intent", "ble", "webrtc", "link", "count", "lists", "serial", "fs", "common", "dm", "gamepad", "llm"];
+  var NAP_IMPLEMENTATIONS = {
+    shell: {
+      proposal: { url: "https://github.com/napplet/naps/pull/101", status: "merged", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Optional readiness and environment binding has focused shim and reference-runtime coverage.",
+      evidence: ["packages/nap/src/shell/shim.test.ts"]
+    },
+    relay: {
+      proposal: { url: "https://github.com/napplet/naps/pull/2", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Relay reads, publishing, and subscription lifecycle have maintained shim and integration tests; upstream naming remains under review.",
+      evidence: ["packages/nap/src/relay/shim.test.ts"],
+      implementationReference: { revision: "cb8f8eabb2d09439e9d174cb9eb6ef2caad0eca1", evidence: ".planning/quick/260703-ghg-align-napplet-packages-with-nap-relayeve/260703-ghg-SUMMARY.md", scope: "RelayEventResult sidecar migration; subsequent changes are not covered." }
+    },
+    identity: {
+      proposal: { url: "https://github.com/napplet/naps/pull/102", status: "merged", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Read-only identity queries and updates have focused binding and reference-runtime coverage.",
+      evidence: ["packages/nap/src/identity/shim.test.ts"]
+    },
+    storage: {
+      proposal: { url: "https://github.com/napplet/naps/pull/3", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Key-value binding has focused request/result tests and tutorial usage; host storage isolation remains the host responsibility.",
+      evidence: ["packages/nap/src/storage/shim.test.ts"]
+    },
+    inc: {
+      proposal: { url: "https://github.com/napplet/naps/pull/104", status: "merged", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Topic and channel bindings have compatibility tests and authenticated-endpoint reference-runtime coverage.",
+      evidence: ["packages/nap/src/inc/shim.ts", "packages/conformance-cli/src/browser.test.ts"]
+    },
+    theme: {
+      proposal: { url: "https://github.com/napplet/naps/pull/103", status: "merged", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Theme queries and pushed updates have focused binding and opaque-iframe integration coverage.",
+      evidence: ["packages/nap/src/theme/shim.test.ts", "packages/conformance-cli/src/browser.test.ts"]
+    },
+    keys: {
+      proposal: { url: "https://github.com/napplet/naps/pull/9", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "experimental",
+      rationale: "Keyboard binding ships, but dedicated domain regression coverage is limited; retain explicit evaluation opt-in.",
+      evidence: ["packages/nap/src/keys/shim.ts"]
+    },
+    media: {
+      proposal: { url: "https://github.com/napplet/naps/pull/10", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Session creation and playback binding have focused regression coverage; proposed torrent playback amendments are not implied.",
+      evidence: ["packages/nap/src/media/shim.test.ts"]
+    },
+    notify: {
+      proposal: { url: "https://github.com/napplet/naps/pull/11", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "experimental",
+      rationale: "Notification binding ships with limited dedicated domain regression evidence; broader host integration confidence is unverified.",
+      evidence: ["packages/nap/src/notify/shim.ts"]
+    },
+    config: {
+      proposal: { url: "https://github.com/napplet/naps/pull/14", status: "draft", checkedAt: "2026-10-31" },
+      maturity: "exploratory",
+      rationale: "Configuration binding is tested, but the upstream draft is marked MAY DEFER; use for design exploration.",
+      evidence: ["packages/nap/src/config/shim.test.ts"]
+    },
+    resource: {
+      proposal: { url: "https://github.com/napplet/naps/pull/80", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Resource fetching has focused shim and type tests; the reverted merge and reopened proposal do not change that implementation assessment.",
+      evidence: ["packages/nap/src/resource/shim.test.ts"],
+      implementationReference: { revision: "8e75eadf317d7fe809415e4755cd48f63cfb63f3", evidence: ".planning/quick/260703-ghg-align-napplet-packages-with-nap-relayeve/260703-ghg-SUMMARY.md", scope: "Shared ResourceSidecarEntry types during the sidecar migration; subsequent resource changes are not covered." }
+    },
+    cvm: {
+      proposal: { url: "https://github.com/napplet/naps/pull/31", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "experimental",
+      rationale: "Session and registry bindings are tested; upstream explicitly marks the contract NEEDS WORK.",
+      evidence: ["packages/nap/src/cvm/shim.test.ts"]
+    },
+    outbox: {
+      proposal: { url: "https://github.com/napplet/naps/pull/32", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Routing and subscription bindings have focused tests and an integration regression for structured-clone boundaries.",
+      evidence: ["packages/nap/src/outbox/shim.test.ts", "packages/nap/src/boundary-integration.test.ts"],
+      implementationReference: { revision: "57db924bac022cc14c67d9fca1a4d92cf1bd4725", evidence: ".planning/quick/260703-ghg-align-napplet-packages-with-nap-relayeve/260703-ghg-SUMMARY.md", scope: "RelayEventResult and stream lifecycle migration; subsequent changes are not covered." }
+    },
+    upload: {
+      proposal: { url: "https://github.com/napplet/naps/pull/33", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Upload binding has focused tests for request/result behavior; host rail support remains runtime-specific.",
+      evidence: ["packages/nap/src/upload/shim.test.ts"]
+    },
+    intent: {
+      proposal: { url: "https://github.com/napplet/naps/pull/91", status: "merged", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Convention normalization and dispatch have focused binding and reference-runtime integration tests.",
+      evidence: ["packages/nap/src/intent/shim.test.ts"]
+    },
+    ble: {
+      proposal: { url: "https://github.com/napplet/naps/pull/62", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "experimental",
+      rationale: "GATT binding has unit coverage; real-device behavior across host backends is not established by these tests.",
+      evidence: ["packages/nap/src/ble/shim.test.ts"]
+    },
+    webrtc: {
+      proposal: { url: "https://github.com/napplet/naps/pull/59", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "experimental",
+      rationale: "Signaling and session binding have unit coverage; interoperable live peer sessions remain unverified here.",
+      evidence: ["packages/nap/src/webrtc/shim.test.ts"]
+    },
+    link: {
+      proposal: { url: "https://github.com/napplet/naps/pull/53", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "The small link-opening binding has focused regression coverage; navigation authorization stays with the host.",
+      evidence: ["packages/nap/src/link/shim.test.ts"]
+    },
+    count: {
+      proposal: { url: "https://github.com/napplet/naps/pull/69", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "experimental",
+      rationale: "Count binding is tested, but accuracy and aggregation across real relay backends remain outside that evidence.",
+      evidence: ["packages/nap/src/count/shim.test.ts"]
+    },
+    lists: {
+      proposal: { url: "https://github.com/napplet/naps/pull/68", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "experimental",
+      rationale: "List mutation binding is tested; concurrent real-host mutation behavior is not established by binding tests.",
+      evidence: ["packages/nap/src/lists/shim.test.ts"]
+    },
+    serial: {
+      proposal: { url: "https://github.com/napplet/naps/pull/61", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "experimental",
+      rationale: "Serial binding has unit coverage; device and native-host integration evidence is limited.",
+      evidence: ["packages/nap/src/serial/shim.test.ts"]
+    },
+    fs: {
+      proposal: { url: "https://github.com/napplet/naps/pull/88", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "experimental",
+      rationale: "Filesystem binding has MVP coverage; portability and authorization across storage backends remain under evaluation.",
+      evidence: ["packages/nap/src/fs/shim.test.ts"]
+    },
+    common: {
+      proposal: { url: "https://github.com/napplet/naps/pull/67", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "experimental",
+      rationale: "Social action binding is tested; broader host integration and evolving action semantics warrant explicit opt-in.",
+      evidence: ["packages/nap/src/common/shim.test.ts"]
+    },
+    dm: {
+      proposal: { url: "https://github.com/napplet/naps/pull/74", status: "draft", checkedAt: "2026-10-31" },
+      maturity: "experimental",
+      rationale: "Direct-message binding has shim and type coverage; transport interoperability is not established by those tests.",
+      evidence: ["packages/nap/src/dm/shim.test.ts"]
+    },
+    gamepad: {
+      proposal: { url: "https://github.com/napplet/naps/pull/130", status: "in-review", checkedAt: "2026-10-31" },
+      maturity: "supported",
+      rationale: "Cross-repository delivery includes binding, security, runtime, and conformance verification; the reopened proposal is still subject to change.",
+      evidence: ["packages/nap/src/gamepad/shim.test.ts", ".planning/phases/163-nap-gamepad-across-repositories/163-VERIFICATION.md"],
+      implementationReference: { revision: "0b28f77e3dfa0f07dd7c0f9d61a7090ee99f3a5e", evidence: ".planning/phases/163-nap-gamepad-across-repositories/163-SECURITY.md", scope: "Phase 163 binding, runtime isolation, and conformance verification." }
+    },
+    llm: {
+      proposal: { url: "https://github.com/napplet/naps/pull/134", status: "draft", checkedAt: "2026-10-31" },
+      maturity: "exploratory",
+      rationale: "Early published draft has binding and mock-runtime tests; provider behavior and API design remain exploratory.",
+      evidence: ["packages/nap/src/llm/shim.test.ts", "packages/conformance-cli/src/browser.test.ts"]
+    }
+  };
+  for (const entry of Object.values(NAP_IMPLEMENTATIONS)) {
+    Object.freeze(entry.proposal);
+    Object.freeze(entry.evidence);
+    if (entry.implementationReference) Object.freeze(entry.implementationReference);
+    Object.freeze(entry);
+  }
+  Object.freeze(NAP_IMPLEMENTATIONS);
+  function getNapImplementation(domain) {
+    return Object.hasOwn(NAP_IMPLEMENTATIONS, domain) ? NAP_IMPLEMENTATIONS[domain] : void 0;
+  }
+  function selectNapDomains(options) {
+    const allowed = new Set(options.allowedMaturities ?? ["supported"]);
+    const optIn = new Set(options.optIn ?? []);
+    const domains = [];
+    const excluded = [];
+    for (const domain of new Set(options.candidates)) {
+      const metadata = getNapImplementation(domain);
+      if (!metadata) {
+        excluded.push({ domain, reason: "unknown-domain" });
+      } else if (!metadata.maturity || !["supported", "experimental", "exploratory"].includes(metadata.maturity)) {
+        excluded.push({ domain, reason: "unclassified" });
+      } else if (allowed.has(metadata.maturity) || optIn.has(domain)) {
+        domains.push(domain);
+      } else {
+        excluded.push({ domain, reason: "maturity-not-allowed", maturity: metadata.maturity });
+      }
+    }
+    return { domains, excluded };
+  }
   function createDispatch() {
     const handlers = /* @__PURE__ */ new Map();
     function registerNap2(domain, handler) {
@@ -1110,13 +1301,15 @@ var NappletConformanceHostBundle = (() => {
   }
   function createReferenceHandler(options) {
     const initialized = /* @__PURE__ */ new Set();
+    const hostDomains = options.domains ? new Set(options.domains) : null;
     const llm = createLlmHandlers();
     const handle2 = (endpoint, envelope) => {
       const type = getEnvelopeType(envelope);
       const verdict = validateEnvelope(envelope);
       options.records.push({ envelope, verdict, timestamp: options.now() });
       if (!type || !verdict.ok) return [];
-      const domains = endpoint.domains ?? NAP_DOMAINS;
+      const candidates = endpoint.domains ?? NAP_DOMAINS;
+      const domains = hostDomains ? candidates.filter((domain) => hostDomains.has(domain)) : candidates;
       if (!domains.includes(type.slice(0, type.indexOf(".")))) return [];
       if (type === "shell.ready") {
         if (initialized.has(endpoint.id)) return [];
@@ -1222,6 +1415,7 @@ var NappletConformanceHostBundle = (() => {
     const handleFrom = createReferenceHandler({
       now: options.now ?? Date.now,
       records,
+      domains: options.domains,
       queueDelivery: deliveries.queue,
       intents: createIntentHandlers(deliveries.queue, options.manifests, options.defaults)
     });
@@ -1257,56 +1451,6 @@ var NappletConformanceHostBundle = (() => {
       }
     };
   }
-  var LLM_PRELUDE_SOURCE = `
-  if (domains.includes('llm')) {
-    const llmFields = { 'llm.select.result': 'model', 'llm.describe.result': 'model', 'llm.generate.result': 'result', 'llm.cancel.result': 'cancelled' };
-    const llmDeltas = new Map();
-    window.addEventListener('message', (event) => {
-      if (event.source !== window.parent) return;
-      const msg = event.data;
-      if (!msg || typeof msg !== 'object' || msg.type !== 'llm.delta' || 'id' in msg || typeof msg.requestId !== 'string') return;
-      const entry = llmDeltas.get(msg.requestId);
-      if (!entry || typeof msg.sequence !== 'number' || typeof msg.text !== 'string') return;
-      if (msg.sequence !== entry.next) { entry.next = Infinity; return; }
-      entry.next += 1;
-      if (entry.onDelta) entry.onDelta({ requestId: msg.requestId, sequence: msg.sequence, text: msg.text });
-    });
-    const llmRequest = (payload, id) => {
-      const type = payload.type;
-      return request(id === undefined ? payload : { ...payload, id }, type + '.result').then((message) => {
-        const field = llmFields[message.type];
-        const hasValue = message[field] !== undefined && message[field] !== null;
-        const hasError = message.error !== undefined && message.error !== null;
-        if (hasValue === hasError) throw new Error(type + '.result must carry exactly one of ' + field + ' or error');
-        if (hasError) {
-          const failure = new Error(String(message.error.message));
-          failure.name = 'LlmError';
-          failure.code = message.error.code;
-          throw failure;
-        }
-        return message[field];
-      });
-    };
-    napplet.llm = {
-      select: (requirements) => llmRequest(requirements === undefined ? { type: 'llm.select' } : { type: 'llm.select', requirements }),
-      describe: (handle) => llmRequest({ type: 'llm.describe', handle }),
-      generate: (generation, options) => {
-        const id = nextId();
-        const entry = { next: 0, onDelta: options && options.onDelta };
-        llmDeltas.set(id, entry);
-        const signal = options && options.signal;
-        const abort = () => { napplet.llm.cancel(id).catch(() => undefined); };
-        if (signal) { if (signal.aborted) abort(); else signal.addEventListener('abort', abort, { once: true }); }
-        const pendingGeneration = llmRequest({ type: 'llm.generate', request: generation }, id).finally(() => {
-          llmDeltas.delete(id);
-          if (signal) signal.removeEventListener('abort', abort);
-        });
-        return Object.assign(pendingGeneration, { requestId: id });
-      },
-      cancel: (requestId) => llmRequest({ type: 'llm.cancel', requestId }),
-    };
-  }
-`;
   var INTERNAL_BOOT_ERROR = "__nappletConformance.error";
   var INTERNAL_INSTALLED = "__nappletConformance.installed";
   function sleep(ms) {
@@ -1315,34 +1459,6 @@ var NappletConformanceHostBundle = (() => {
   function escapeHtmlAttr(value) {
     return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
   }
-  var GAMEPAD_STATE_TOOLS_SOURCE = `(() => {
-  const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
-  const numberIn = (value, min, max) => typeof value === 'number' && Number.isFinite(value) && value >= min && value <= max;
-  const isGamepadState = (value) => {
-    if (!record(value) || typeof value.available !== 'boolean' || typeof value.focused !== 'boolean' || !Array.isArray(value.pads)) return false;
-    if (value.available) {
-      if (value.reason !== undefined) return false;
-    } else if (value.focused || (value.reason !== 'blocked' && value.reason !== 'unavailable')) return false;
-    return Array.from(value.pads).every((pad) => {
-      if (pad === null) return true;
-      if (!record(pad) || !Number.isInteger(pad.index) || pad.index < 0 || typeof pad.id !== 'string' || typeof pad.mapping !== 'string' || pad.connected !== true) return false;
-      if (typeof pad.timestamp !== 'number' || !Number.isFinite(pad.timestamp) || !Array.isArray(pad.axes) || !Array.isArray(pad.buttons)) return false;
-      if (!value.focused && pad.timestamp !== 0) return false;
-      if (!Array.from(pad.axes).every((axis) => numberIn(axis, -1, 1) && (value.focused || axis === 0))) return false;
-      return Array.from(pad.buttons).every((button) => record(button) && numberIn(button.value, 0, 1) && typeof button.pressed === 'boolean' && typeof button.touched === 'boolean' && (value.focused || (button.value === 0 && !button.pressed && !button.touched)));
-    });
-  };
-  const copyGamepadState = (state) => {
-    const copy = { available: state.available, focused: state.focused };
-    if (state.reason !== undefined) copy.reason = state.reason;
-    copy.pads = state.pads.map((pad) => pad === null ? null : {
-      index: pad.index, id: pad.id, mapping: pad.mapping, connected: pad.connected,
-      timestamp: pad.timestamp, axes: pad.axes.slice(), buttons: pad.buttons.map((button) => ({ value: button.value, pressed: button.pressed, touched: button.touched })),
-    });
-    return copy;
-  };
-  return { isGamepadState, copyGamepadState };
-})()`;
   function errorObserver() {
     return `(() => {
     const report = (reason) => {
@@ -1353,128 +1469,11 @@ var NappletConformanceHostBundle = (() => {
     window.addEventListener('unhandledrejection', (event) => report(event.reason));
   })();`;
   }
-  var FALLBACK_RUNTIME_OPEN = `
-(() => {
-  const domains = `;
-  var FALLBACK_RUNTIME_BEFORE_GAMEPAD_TOOLS = `;
-  const napplet = {};
-  for (const domain of domains) {
-    if (domain === 'resource' || domain === 'gamepad') napplet[domain] = {};
-  }
-  const gamepadTools = `;
-  var FALLBACK_RUNTIME_AFTER_GAMEPAD_TOOLS = `;
-  let gamepadState = { available: true, focused: false, pads: [] };
-  const gamepadHandlers = new Set();
-  // Subscribe on first use, like the nap binding, so napplets that never touch
-  // gamepad emit no gamepad traffic for checks to attribute to them.
-  let gamepadSubscribed = false;
-  const gamepadSubscribe = () => {
-    if (gamepadSubscribed) return;
-    gamepadSubscribed = true;
-    window.parent.postMessage({ type: 'gamepad.subscribe' }, '*');
-  };
-  const pending = new Map();
-  let seq = 0;
-  const nextId = () => {
-    try {
-      if (window.crypto && typeof window.crypto.randomUUID === 'function') return window.crypto.randomUUID();
-    } catch {}
-    seq += 1;
-    return 'conformance-' + Date.now().toString(36) + '-' + seq.toString(36);
-  };
-  const request = (message, resultType, errorType) => new Promise((resolve, reject) => {
-    const id = message.id || nextId();
-    const timeout = window.setTimeout(() => {
-      pending.delete(id);
-      reject(new Error(message.type + ' timed out'));
-    }, 5000);
-    pending.set(id, { resolve, reject, resultType, errorType, timeout });
-    window.parent.postMessage({ ...message, id }, '*');
-  });
-  window.addEventListener('message', (event) => {
-    if (event.source !== window.parent) return;
-    const msg = event.data;
-    if (gamepadSubscribed && msg && msg.type === 'gamepad.state' && !('id' in msg) && gamepadTools.isGamepadState(msg)) {
-      gamepadState = gamepadTools.copyGamepadState(msg);
-      const recipients = Array.from(gamepadHandlers);
-      for (const entry of recipients) {
-        if (!gamepadHandlers.has(entry)) continue;
-        try { entry.handler(gamepadTools.copyGamepadState(gamepadState)); }
-        catch (error) { queueMicrotask(() => { throw error; }); }
-      }
-      return;
-    }
-    if (!msg || typeof msg !== 'object' || typeof msg.id !== 'string') return;
-    const slot = pending.get(msg.id);
-    if (!slot) return;
-    if (msg.type !== slot.resultType && msg.type !== slot.errorType) return;
-    pending.delete(msg.id);
-    window.clearTimeout(slot.timeout);
-    if (msg.type === slot.errorType) {
-      slot.reject(new Error(msg.message ? msg.error + ': ' + msg.message : String(msg.error || 'request failed')));
-      return;
-    }
-    slot.resolve(msg);
-  });
-  if (napplet.gamepad) {
-    napplet.gamepad = {
-      get available() { gamepadSubscribe(); return gamepadState.available; },
-      get focused() { gamepadSubscribe(); return gamepadState.focused; },
-      getGamepads() { gamepadSubscribe(); return gamepadTools.copyGamepadState(gamepadState).pads; },
-      onChange(handler) {
-        const entry = { handler };
-        gamepadHandlers.add(entry);
-        gamepadSubscribe();
-        return { close() { gamepadHandlers.delete(entry); } };
-      },
-    };
-  }
-  if (napplet.resource) {
-    napplet.resource.info = () =>
-      request({ type: 'resource.info' }, 'resource.info.result', 'resource.info.error')
-        .then((msg) => msg.info);
-    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 = (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: () => {} };
-      let objectUrl = '';
-      let revoked = false;
-      const ready = napplet.resource.bytes(url).then((blob) => {
-        if (revoked) return;
-        objectUrl = URL.createObjectURL(blob);
-        handle.url = objectUrl;
-        return objectUrl;
-      });
-      handle.revoke = () => {
-        if (revoked) return;
-        revoked = true;
-        if (objectUrl) URL.revokeObjectURL(objectUrl);
-      };
-      Object.defineProperty(handle, 'ready', { value: ready, enumerable: false });
-      return handle;
-    };
-  }
-  ${LLM_PRELUDE_SOURCE}
-  window.napplet = napplet;
-  `;
-  var FALLBACK_RUNTIME_CLOSE = `
-})();
-`;
   function runtimePrelude(domains, runtimePreludeSource) {
     const installed = `window.parent.postMessage({ type: '${INTERNAL_INSTALLED}', installed: !!window.napplet }, '*');`;
-    if (runtimePreludeSource !== void 0) {
-      return `${runtimePreludeSource}
+    return `${runtimePreludeSource}
 ;globalThis.NappletShimPrelude.install(${JSON.stringify({ domains })});
 ${installed}`;
-    }
-    return FALLBACK_RUNTIME_OPEN + JSON.stringify(domains) + FALLBACK_RUNTIME_BEFORE_GAMEPAD_TOOLS + GAMEPAD_STATE_TOOLS_SOURCE + FALLBACK_RUNTIME_AFTER_GAMEPAD_TOOLS + installed + FALLBACK_RUNTIME_CLOSE;
   }
   function injectRuntime(html, url, domains, runtimePreludeSource) {
     const base = `<base href="${escapeHtmlAttr(url)}">`;
@@ -1505,7 +1504,7 @@ ${installed}`;
     return response.text();
   }
   async function bootOnce(domains, opts, doc, win) {
-    const shell = createReferenceShell();
+    const shell = createReferenceShell({ domains });
     const iframe = doc.createElement("iframe");
     iframe.setAttribute("sandbox", opts.allowSameOrigin ? "allow-scripts allow-same-origin" : "allow-scripts");
     iframe.setAttribute("allow", "gamepad 'none'");
@@ -1573,7 +1572,9 @@ ${installed}`;
       allowSameOrigin: options.allowSameOrigin ?? false,
       runtimePreludeSource: options.runtimePreludeSource
     };
-    const primary = await bootOnce(NAP_DOMAINS, resolved, doc, win);
+    const candidates = options.domains ?? NAP_DOMAINS;
+    const domains = options.maturity ? selectNapDomains({ ...options.maturity, candidates }).domains : candidates;
+    const primary = await bootOnce(domains, resolved, doc, win);
     let degraded = null;
     if (options.runDegraded ?? true) {
       const d = await bootOnce([], resolved, doc, win);