@agimon-ai/doompi-web-security 0.0.1-alpha.2

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Vuong Ngo
+Copyright (c) 2026 pulseaiclub
+
+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/README.md

@@ -0,0 +1,85 @@
+# @agimon-ai/doompi-web-security
+
+Shared security primitives for the DoomPi web cockpit: the sealed-channel envelope, its `node:crypto`
+and WebCrypto halves, and the signed bundle manifest.
+
+This package holds no policy and starts nothing. It exists because three different programs need to
+agree byte for byte on the same crypto: the cockpit hub (Node), the cockpit page (browser), and every
+web plugin bundled into that page.
+
+## Why it is a package
+
+A plugin in another package cannot import from a client application, and the sealed transport is a
+module singleton whose nonce counters every caller must share. A second copy would start counting at
+zero and the receiver would reject everything it sent as a replay. One package, deduped in the
+bundle, is what makes that impossible.
+
+## Subpaths
+
+| Import                                   | Runs where | What it carries                                                                                          |
+| ---------------------------------------- | ---------- | -------------------------------------------------------------------------------------------------------- |
+| `@agimon-ai/doompi-web-security`         | both       | The envelope contract, the bundle manifest shape, the canonical serialization both sides sign and verify |
+| `@agimon-ai/doompi-web-security/browser` | the page   | The WebCrypto channel and `sealedTransport`, the shared instance plugins use                             |
+| `@agimon-ai/doompi-web-security/node`    | the hub    | The `node:crypto` channel, the host handshake, and the bundle signer                                     |
+
+## The sealed channel
+
+A hosted tunnel terminates TLS at its provider's edge, so without application sealing everything the
+cockpit carries is plaintext to them. Sealing the payload underneath their TLS leaves them a relay that
+sees timing and sizes but not content.
+
+The QR pairing path anchors key exchange out of band. The host's ephemeral P-256 public key is printed on
+the screen the user is holding, so the relay cannot substitute its own. A returning device instead receives
+the current public key after proving a passkey. That path depends on the trusted code-delivery edge described
+above, and the key itself is public rather than secret.
+
+Three properties worth knowing, because getting any of them wrong is silent:
+
+- **Separate keys per direction.** Derived with different HKDF info strings, so a message the server
+  sent can never be replayed back at it as though the client had sent it.
+- **Nonces are a random per-channel prefix plus a monotonic counter**, never random per message. A
+  repeated nonce under one AES-GCM key leaks the XOR of two plaintexts and the authentication subkey;
+  96 bits is small enough that random nonces collide at a rate worth caring about.
+- **Both directions are serialized.** Sealing advances the counter and opening demands it strictly
+  increase, so overlapping asynchronous calls are a correctness bug, not a race worth tolerating.
+  `createSerialQueue` is what prevents a burst of socket sends from reordering into a self-inflicted
+  replay.
+
+Every failure names itself. A decryption failure otherwise shows up as a blank page with nothing to
+go on.
+
+## The signed bundle-manifest primitive
+
+The signer can support a separately distributed verifier whose bootstrap and public key are already
+trusted. It hashes every asset and signs a canonical manifest with ECDSA P-256.
+
+It is not a self-protection mechanism for a browser SPA. A server or TLS edge that can replace the page
+can also remove an in-page verifier or replace the key it trusts. DoomPi's Cloudflare transport treats
+Cloudflare as a trusted code-delivery boundary, so the cockpit does not use this primitive to claim
+protection from a malicious edge.
+
+`canonicalManifest` is hand-rolled rather than `JSON.stringify` of the whole object, because a signature
+is only worth anything if signer and verifier agree byte for byte, and key order in a JSON object is an
+implementation detail.
+
+## Public API
+
+```ts
+import { canonicalManifest, describeSealedFailure, isSealedEnvelope } from '@agimon-ai/doompi-web-security';
+import { sealedTransport } from '@agimon-ai/doompi-web-security/browser';
+import { createBundleSigner, createHostHandshake } from '@agimon-ai/doompi-web-security/node';
+```
+
+## Development
+
+```bash
+pnpm build
+pnpm typecheck
+pnpm test
+pnpm lint
+```
+
+The round-trip test is the one that matters: it seals with `node:crypto` and opens with real
+WebCrypto, so the two implementations cannot drift apart without a failure.
+
+Maintained by [Agimon](https://agimon.ai/about).

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,s)=>(s=n==null?{}:e(i(n)),o(r||!n||!n.__esModule||!a.call(n,`default`)?t(s,`default`,{value:n,enumerable:!0}):s,n));exports.__toESM=s;

package/dist/adapters/browserSealedChannel.cjs

@@ -0,0 +1,2 @@
+const e=require("../types/sealedChannel.cjs"),t={name:`ECDH`,namedCurve:`P-256`},n=`AES-GCM`;function r(e){let t;try{t=atob(e.replaceAll(`-`,`+`).replaceAll(`_`,`/`))}catch{return}let n=new Uint8Array(new ArrayBuffer(t.length));for(let e=0;e<t.length;e+=1)n[e]=t.charCodeAt(e);return n}function i(e){let t=``;for(let n of e)t+=String.fromCharCode(n);return btoa(t).replaceAll(`+`,`-`).replaceAll(`/`,`_`).replaceAll(`=`,``)}function a(e){let t=new Uint8Array(new ArrayBuffer(e.length));return t.set(e),t.buffer}async function o(t,r){let i=await crypto.subtle.importKey(`raw`,t,`HKDF`,!1,[`deriveKey`]);return await crypto.subtle.deriveKey({name:`HKDF`,hash:`SHA-256`,salt:a(new TextEncoder().encode(`doompi/sealed/v1`)),info:a(new TextEncoder().encode(e.infoFor(r)))},i,{name:n,length:256},!1,[`encrypt`,`decrypt`])}function s(e,t){let n=new Uint8Array(12);return n.set(e.subarray(0,4),0),new DataView(n.buffer).setBigUint64(4,t,!1),n}function c(t,o,c){let l=0n,u=-1n;return{async seal(r){if(l>=BigInt(e.MAX_MESSAGES_PER_KEY))return{ok:!1,failure:`exhausted`};let o=s(c,l),u=await crypto.subtle.encrypt({name:n,iv:a(o),tagLength:128},t,a(r));return l+=1n,{ok:!0,envelope:{v:1,n:i(o),c:i(new Uint8Array(u))}}},async open(t){let i=t;if(typeof i?.n!=`string`||typeof i.c!=`string`)return{ok:!1,failure:`malformed`};if(i.v!==1)return{ok:!1,failure:`version`};if(!e.isSealedEnvelope(t))return{ok:!1,failure:`malformed`};let s=r(t.n),c=r(t.c);if(s===void 0||c===void 0||s.length!==12||c.length<16)return{ok:!1,failure:`malformed`};let l=new DataView(a(s)).getBigUint64(4,!1);if(l<=u)return{ok:!1,failure:`replay`};let d;try{d=await crypto.subtle.decrypt({name:n,iv:a(s),tagLength:128},o,a(c))}catch{return{ok:!1,failure:`auth`}}return u=l,{ok:!0,plaintext:new Uint8Array(d)}}}}async function l(e){if(globalThis.crypto?.subtle!==void 0)try{let n=await crypto.subtle.generateKey(t,!1,[`deriveBits`]),s=r(e);if(s===void 0)return;let l=await crypto.subtle.importKey(`raw`,a(s),t,!1,[]),u=await crypto.subtle.deriveBits({name:`ECDH`,public:l},n.privateKey,256),d=i(new Uint8Array(await crypto.subtle.exportKey(`raw`,n.publicKey)));return{channel:c(await o(u,`c2s`),await o(u,`s2c`),new Uint8Array(4)),clientPublicKey:d}}catch{return}}async function u(e,t,n){return c(await o(e,t),await o(e,t===`c2s`?`s2c`:`c2s`),n)}exports.channelFromSecret=u,exports.connectSealedChannel=l;
+//# sourceMappingURL=browserSealedChannel.cjs.map

package/dist/adapters/browserSealedChannel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserSealedChannel.cjs","names":["infoFor","MAX_MESSAGES_PER_KEY","isSealedEnvelope"],"sources":["../../src/adapters/browserSealedChannel.ts"],"sourcesContent":["import {\n  MAX_MESSAGES_PER_KEY,\n  NONCE_BYTES,\n  NONCE_PREFIX_BYTES,\n  SEALED_VERSION,\n  type SealedDirection,\n  type SealedEnvelope,\n  type SealedFailure,\n  infoFor,\n  isSealedEnvelope,\n} from '../types/sealedChannel.ts';\n\n/**\n * The browser half of the sealed channel.\n *\n * Mirrors `nodeSealedChannel.ts` exactly, on WebCrypto instead of\n * `node:crypto`. Two implementations rather than one because a shared one would\n * drag node builtins into every browser bundle that imports it, and this\n * package is imported by plugins that ship to the page. The envelope contract\n * they both read lives in `../types/sealedChannel.ts`, and a round-trip test\n * pins the two together so they cannot drift.\n */\n\nconst KEY_ALGORITHM = { name: 'ECDH', namedCurve: 'P-256' } as const;\nconst CIPHER = 'AES-GCM';\nconst KEY_BITS = 256;\nconst TAG_BITS = 128;\nconst TAG_BYTES = 16;\nconst HKDF_SALT = 'doompi/sealed/v1';\n\nexport type SealResult = { ok: true; envelope: SealedEnvelope } | { ok: false; failure: SealedFailure };\nexport type OpenResult = { ok: true; plaintext: Uint8Array } | { ok: false; failure: SealedFailure };\n\nexport interface SealedChannel {\n  seal(plaintext: Uint8Array): Promise<SealResult>;\n  open(envelope: unknown): Promise<OpenResult>;\n}\n\n/** Undefined rather than a throw: a malformed field is a verdict, not an exception. */\nfunction bytes(value: string): Uint8Array | undefined {\n  let binary: string;\n  try {\n    binary = atob(value.replaceAll('-', '+').replaceAll('_', '/'));\n  } catch {\n    return undefined;\n  }\n  const out = new Uint8Array(new ArrayBuffer(binary.length));\n  for (let index = 0; index < binary.length; index += 1) out[index] = binary.charCodeAt(index);\n  return out;\n}\n\nfunction base64Url(value: Uint8Array): string {\n  let binary = '';\n  for (const byte of value) binary += String.fromCharCode(byte);\n  return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replaceAll('=', '');\n}\n\nfunction view(value: Uint8Array): ArrayBuffer {\n  const copy = new Uint8Array(new ArrayBuffer(value.length));\n  copy.set(value);\n  return copy.buffer;\n}\n\nasync function derive(secret: ArrayBuffer, direction: SealedDirection): Promise<CryptoKey> {\n  const material = await crypto.subtle.importKey('raw', secret, 'HKDF', false, ['deriveKey']);\n  return await crypto.subtle.deriveKey(\n    {\n      name: 'HKDF',\n      hash: 'SHA-256',\n      salt: view(new TextEncoder().encode(HKDF_SALT)),\n      info: view(new TextEncoder().encode(infoFor(direction))),\n    },\n    material,\n    { name: CIPHER, length: KEY_BITS },\n    false,\n    ['encrypt', 'decrypt'],\n  );\n}\n\nfunction nonceFor(prefix: Uint8Array, counter: bigint): Uint8Array {\n  const nonce = new Uint8Array(NONCE_BYTES);\n  nonce.set(prefix.subarray(0, NONCE_PREFIX_BYTES), 0);\n  new DataView(nonce.buffer).setBigUint64(NONCE_PREFIX_BYTES, counter, false);\n  return nonce;\n}\n\nfunction channelFrom(sendKey: CryptoKey, receiveKey: CryptoKey, noncePrefix: Uint8Array): SealedChannel {\n  let sendCounter = 0n;\n  let highestReceived = -1n;\n\n  return {\n    async seal(plaintext) {\n      if (sendCounter >= BigInt(MAX_MESSAGES_PER_KEY)) return { ok: false, failure: 'exhausted' };\n      const nonce = nonceFor(noncePrefix, sendCounter);\n      const sealed = await crypto.subtle.encrypt(\n        { name: CIPHER, iv: view(nonce), tagLength: TAG_BITS },\n        sendKey,\n        view(plaintext),\n      );\n      sendCounter += 1n;\n      return {\n        ok: true,\n        envelope: { v: SEALED_VERSION, n: base64Url(nonce), c: base64Url(new Uint8Array(sealed)) },\n      };\n    },\n\n    async open(envelope) {\n      // Shape before version, matching the server: something with no `v` at all\n      // is malformed rather than a protocol skew.\n      const shape = envelope as { v?: unknown; n?: unknown; c?: unknown } | null | undefined;\n      if (typeof shape?.n !== 'string' || typeof shape.c !== 'string') return { ok: false, failure: 'malformed' };\n      if (shape.v !== SEALED_VERSION) return { ok: false, failure: 'version' };\n      if (!isSealedEnvelope(envelope)) return { ok: false, failure: 'malformed' };\n      const nonce = bytes(envelope.n);\n      const body = bytes(envelope.c);\n      if (nonce === undefined || body === undefined) return { ok: false, failure: 'malformed' };\n      if (nonce.length !== NONCE_BYTES || body.length < TAG_BYTES) return { ok: false, failure: 'malformed' };\n      const counter = new DataView(view(nonce)).getBigUint64(NONCE_PREFIX_BYTES, false);\n      if (counter <= highestReceived) return { ok: false, failure: 'replay' };\n      let plaintext: ArrayBuffer;\n      try {\n        plaintext = await crypto.subtle.decrypt(\n          { name: CIPHER, iv: view(nonce), tagLength: TAG_BITS },\n          receiveKey,\n          view(body),\n        );\n      } catch {\n        // A failed tag means the message was altered in transit; there is no\n        // partial result worth salvaging.\n        return { ok: false, failure: 'auth' };\n      }\n      // Only after the tag verified, so a forged high counter cannot lock out\n      // every message that legitimately follows it.\n      highestReceived = counter;\n      return { ok: true, plaintext: new Uint8Array(plaintext) };\n    },\n  };\n}\n\n/**\n * Completes the handshake against the host key read out of the QR fragment.\n *\n * That key never travelled through the tunnel, which is what makes this\n * authenticated: a relay can watch the client's public key go past and learn\n * nothing, and it cannot substitute the host's because it never carried it.\n */\nexport async function connectSealedChannel(\n  hostPublicKey: string,\n): Promise<{ channel: SealedChannel; clientPublicKey: string } | undefined> {\n  if (globalThis.crypto?.subtle === undefined) return undefined;\n  try {\n    const pair = await crypto.subtle.generateKey(KEY_ALGORITHM, false, ['deriveBits']);\n    const hostKey = bytes(hostPublicKey);\n    if (hostKey === undefined) return undefined;\n    const peer = await crypto.subtle.importKey('raw', view(hostKey), KEY_ALGORITHM, false, []);\n    const secret = await crypto.subtle.deriveBits({ name: 'ECDH', public: peer }, pair.privateKey, KEY_BITS);\n    const clientPublicKey = base64Url(new Uint8Array(await crypto.subtle.exportKey('raw', pair.publicKey)));\n    return {\n      channel: channelFrom(\n        await derive(secret, 'c2s'),\n        await derive(secret, 's2c'),\n        new Uint8Array(NONCE_PREFIX_BYTES),\n      ),\n      clientPublicKey,\n    };\n  } catch {\n    // A malformed host key or a context without ECDH; the caller falls back to\n    // an unsealed channel and says so rather than failing silently.\n    return undefined;\n  }\n}\n\n/** Exposed so a test can build the browser side against a known secret. */\nexport async function channelFromSecret(\n  secret: ArrayBuffer,\n  sendDirection: SealedDirection,\n  noncePrefix: Uint8Array,\n): Promise<SealedChannel> {\n  const send = await derive(secret, sendDirection);\n  const receive = await derive(secret, sendDirection === 'c2s' ? 's2c' : 'c2s');\n  return channelFrom(send, receive, noncePrefix);\n}\n"],"mappings":"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"}

package/dist/adapters/browserSealedChannel.d.cts

@@ -0,0 +1,36 @@
+import { SealedDirection, SealedEnvelope, SealedFailure } from "../types/sealedChannel.cjs";
+//#region src/adapters/browserSealedChannel.d.ts
+type SealResult = {
+  ok: true;
+  envelope: SealedEnvelope;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+type OpenResult = {
+  ok: true;
+  plaintext: Uint8Array;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+interface SealedChannel {
+  seal(plaintext: Uint8Array): Promise<SealResult>;
+  open(envelope: unknown): Promise<OpenResult>;
+}
+/**
+ * Completes the handshake against the host key read out of the QR fragment.
+ *
+ * That key never travelled through the tunnel, which is what makes this
+ * authenticated: a relay can watch the client's public key go past and learn
+ * nothing, and it cannot substitute the host's because it never carried it.
+ */
+declare function connectSealedChannel(hostPublicKey: string): Promise<{
+  channel: SealedChannel;
+  clientPublicKey: string;
+} | undefined>;
+/** Exposed so a test can build the browser side against a known secret. */
+declare function channelFromSecret(secret: ArrayBuffer, sendDirection: SealedDirection, noncePrefix: Uint8Array): Promise<SealedChannel>;
+//#endregion
+export { OpenResult, SealResult, SealedChannel, channelFromSecret, connectSealedChannel };
+//# sourceMappingURL=browserSealedChannel.d.cts.map

package/dist/adapters/browserSealedChannel.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserSealedChannel.d.cts","names":[],"sources":["../../src/adapters/browserSealedChannel.ts"],"mappings":";;KA8BY;EAAe;EAAU,UAAU;;EAAqB;EAAW,SAAS;;KAC5E;EAAe;EAAU,WAAW;;EAAiB;EAAW,SAAS;;UAEpE;EACf,KAAK,WAAW,aAAa,QAAQ;EACrC,KAAK,oBAAoB,QAAQ;;;;;;;;;iBA+Gb,qBACpB,wBACC;EAAU,SAAS;EAAe;;;iBAyBf,kBACpB,QAAQ,aACR,eAAe,iBACf,aAAa,aACZ,QAAQ"}

package/dist/adapters/browserSealedChannel.d.mts

@@ -0,0 +1,36 @@
+import { SealedDirection, SealedEnvelope, SealedFailure } from "../types/sealedChannel.mjs";
+//#region src/adapters/browserSealedChannel.d.ts
+type SealResult = {
+  ok: true;
+  envelope: SealedEnvelope;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+type OpenResult = {
+  ok: true;
+  plaintext: Uint8Array;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+interface SealedChannel {
+  seal(plaintext: Uint8Array): Promise<SealResult>;
+  open(envelope: unknown): Promise<OpenResult>;
+}
+/**
+ * Completes the handshake against the host key read out of the QR fragment.
+ *
+ * That key never travelled through the tunnel, which is what makes this
+ * authenticated: a relay can watch the client's public key go past and learn
+ * nothing, and it cannot substitute the host's because it never carried it.
+ */
+declare function connectSealedChannel(hostPublicKey: string): Promise<{
+  channel: SealedChannel;
+  clientPublicKey: string;
+} | undefined>;
+/** Exposed so a test can build the browser side against a known secret. */
+declare function channelFromSecret(secret: ArrayBuffer, sendDirection: SealedDirection, noncePrefix: Uint8Array): Promise<SealedChannel>;
+//#endregion
+export { OpenResult, SealResult, SealedChannel, channelFromSecret, connectSealedChannel };
+//# sourceMappingURL=browserSealedChannel.d.mts.map

package/dist/adapters/browserSealedChannel.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserSealedChannel.d.mts","names":[],"sources":["../../src/adapters/browserSealedChannel.ts"],"mappings":";;KA8BY;EAAe;EAAU,UAAU;;EAAqB;EAAW,SAAS;;KAC5E;EAAe;EAAU,WAAW;;EAAiB;EAAW,SAAS;;UAEpE;EACf,KAAK,WAAW,aAAa,QAAQ;EACrC,KAAK,oBAAoB,QAAQ;;;;;;;;;iBA+Gb,qBACpB,wBACC;EAAU,SAAS;EAAe;;;iBAyBf,kBACpB,QAAQ,aACR,eAAe,iBACf,aAAa,aACZ,QAAQ"}

package/dist/adapters/browserSealedChannel.mjs

@@ -0,0 +1,2 @@
+import{MAX_MESSAGES_PER_KEY as e,infoFor as t,isSealedEnvelope as n}from"../types/sealedChannel.mjs";const r={name:`ECDH`,namedCurve:`P-256`},i=`AES-GCM`;function a(e){let t;try{t=atob(e.replaceAll(`-`,`+`).replaceAll(`_`,`/`))}catch{return}let n=new Uint8Array(new ArrayBuffer(t.length));for(let e=0;e<t.length;e+=1)n[e]=t.charCodeAt(e);return n}function o(e){let t=``;for(let n of e)t+=String.fromCharCode(n);return btoa(t).replaceAll(`+`,`-`).replaceAll(`/`,`_`).replaceAll(`=`,``)}function s(e){let t=new Uint8Array(new ArrayBuffer(e.length));return t.set(e),t.buffer}async function c(e,n){let r=await crypto.subtle.importKey(`raw`,e,`HKDF`,!1,[`deriveKey`]);return await crypto.subtle.deriveKey({name:`HKDF`,hash:`SHA-256`,salt:s(new TextEncoder().encode(`doompi/sealed/v1`)),info:s(new TextEncoder().encode(t(n)))},r,{name:i,length:256},!1,[`encrypt`,`decrypt`])}function l(e,t){let n=new Uint8Array(12);return n.set(e.subarray(0,4),0),new DataView(n.buffer).setBigUint64(4,t,!1),n}function u(t,r,c){let u=0n,d=-1n;return{async seal(n){if(u>=BigInt(e))return{ok:!1,failure:`exhausted`};let r=l(c,u),a=await crypto.subtle.encrypt({name:i,iv:s(r),tagLength:128},t,s(n));return u+=1n,{ok:!0,envelope:{v:1,n:o(r),c:o(new Uint8Array(a))}}},async open(e){let t=e;if(typeof t?.n!=`string`||typeof t.c!=`string`)return{ok:!1,failure:`malformed`};if(t.v!==1)return{ok:!1,failure:`version`};if(!n(e))return{ok:!1,failure:`malformed`};let o=a(e.n),c=a(e.c);if(o===void 0||c===void 0||o.length!==12||c.length<16)return{ok:!1,failure:`malformed`};let l=new DataView(s(o)).getBigUint64(4,!1);if(l<=d)return{ok:!1,failure:`replay`};let u;try{u=await crypto.subtle.decrypt({name:i,iv:s(o),tagLength:128},r,s(c))}catch{return{ok:!1,failure:`auth`}}return d=l,{ok:!0,plaintext:new Uint8Array(u)}}}}async function d(e){if(globalThis.crypto?.subtle!==void 0)try{let t=await crypto.subtle.generateKey(r,!1,[`deriveBits`]),n=a(e);if(n===void 0)return;let i=await crypto.subtle.importKey(`raw`,s(n),r,!1,[]),l=await crypto.subtle.deriveBits({name:`ECDH`,public:i},t.privateKey,256),d=o(new Uint8Array(await crypto.subtle.exportKey(`raw`,t.publicKey)));return{channel:u(await c(l,`c2s`),await c(l,`s2c`),new Uint8Array(4)),clientPublicKey:d}}catch{return}}async function f(e,t,n){return u(await c(e,t),await c(e,t===`c2s`?`s2c`:`c2s`),n)}export{f as channelFromSecret,d as connectSealedChannel};
+//# sourceMappingURL=browserSealedChannel.mjs.map

package/dist/adapters/browserSealedChannel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserSealedChannel.mjs","names":[],"sources":["../../src/adapters/browserSealedChannel.ts"],"sourcesContent":["import {\n  MAX_MESSAGES_PER_KEY,\n  NONCE_BYTES,\n  NONCE_PREFIX_BYTES,\n  SEALED_VERSION,\n  type SealedDirection,\n  type SealedEnvelope,\n  type SealedFailure,\n  infoFor,\n  isSealedEnvelope,\n} from '../types/sealedChannel.ts';\n\n/**\n * The browser half of the sealed channel.\n *\n * Mirrors `nodeSealedChannel.ts` exactly, on WebCrypto instead of\n * `node:crypto`. Two implementations rather than one because a shared one would\n * drag node builtins into every browser bundle that imports it, and this\n * package is imported by plugins that ship to the page. The envelope contract\n * they both read lives in `../types/sealedChannel.ts`, and a round-trip test\n * pins the two together so they cannot drift.\n */\n\nconst KEY_ALGORITHM = { name: 'ECDH', namedCurve: 'P-256' } as const;\nconst CIPHER = 'AES-GCM';\nconst KEY_BITS = 256;\nconst TAG_BITS = 128;\nconst TAG_BYTES = 16;\nconst HKDF_SALT = 'doompi/sealed/v1';\n\nexport type SealResult = { ok: true; envelope: SealedEnvelope } | { ok: false; failure: SealedFailure };\nexport type OpenResult = { ok: true; plaintext: Uint8Array } | { ok: false; failure: SealedFailure };\n\nexport interface SealedChannel {\n  seal(plaintext: Uint8Array): Promise<SealResult>;\n  open(envelope: unknown): Promise<OpenResult>;\n}\n\n/** Undefined rather than a throw: a malformed field is a verdict, not an exception. */\nfunction bytes(value: string): Uint8Array | undefined {\n  let binary: string;\n  try {\n    binary = atob(value.replaceAll('-', '+').replaceAll('_', '/'));\n  } catch {\n    return undefined;\n  }\n  const out = new Uint8Array(new ArrayBuffer(binary.length));\n  for (let index = 0; index < binary.length; index += 1) out[index] = binary.charCodeAt(index);\n  return out;\n}\n\nfunction base64Url(value: Uint8Array): string {\n  let binary = '';\n  for (const byte of value) binary += String.fromCharCode(byte);\n  return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replaceAll('=', '');\n}\n\nfunction view(value: Uint8Array): ArrayBuffer {\n  const copy = new Uint8Array(new ArrayBuffer(value.length));\n  copy.set(value);\n  return copy.buffer;\n}\n\nasync function derive(secret: ArrayBuffer, direction: SealedDirection): Promise<CryptoKey> {\n  const material = await crypto.subtle.importKey('raw', secret, 'HKDF', false, ['deriveKey']);\n  return await crypto.subtle.deriveKey(\n    {\n      name: 'HKDF',\n      hash: 'SHA-256',\n      salt: view(new TextEncoder().encode(HKDF_SALT)),\n      info: view(new TextEncoder().encode(infoFor(direction))),\n    },\n    material,\n    { name: CIPHER, length: KEY_BITS },\n    false,\n    ['encrypt', 'decrypt'],\n  );\n}\n\nfunction nonceFor(prefix: Uint8Array, counter: bigint): Uint8Array {\n  const nonce = new Uint8Array(NONCE_BYTES);\n  nonce.set(prefix.subarray(0, NONCE_PREFIX_BYTES), 0);\n  new DataView(nonce.buffer).setBigUint64(NONCE_PREFIX_BYTES, counter, false);\n  return nonce;\n}\n\nfunction channelFrom(sendKey: CryptoKey, receiveKey: CryptoKey, noncePrefix: Uint8Array): SealedChannel {\n  let sendCounter = 0n;\n  let highestReceived = -1n;\n\n  return {\n    async seal(plaintext) {\n      if (sendCounter >= BigInt(MAX_MESSAGES_PER_KEY)) return { ok: false, failure: 'exhausted' };\n      const nonce = nonceFor(noncePrefix, sendCounter);\n      const sealed = await crypto.subtle.encrypt(\n        { name: CIPHER, iv: view(nonce), tagLength: TAG_BITS },\n        sendKey,\n        view(plaintext),\n      );\n      sendCounter += 1n;\n      return {\n        ok: true,\n        envelope: { v: SEALED_VERSION, n: base64Url(nonce), c: base64Url(new Uint8Array(sealed)) },\n      };\n    },\n\n    async open(envelope) {\n      // Shape before version, matching the server: something with no `v` at all\n      // is malformed rather than a protocol skew.\n      const shape = envelope as { v?: unknown; n?: unknown; c?: unknown } | null | undefined;\n      if (typeof shape?.n !== 'string' || typeof shape.c !== 'string') return { ok: false, failure: 'malformed' };\n      if (shape.v !== SEALED_VERSION) return { ok: false, failure: 'version' };\n      if (!isSealedEnvelope(envelope)) return { ok: false, failure: 'malformed' };\n      const nonce = bytes(envelope.n);\n      const body = bytes(envelope.c);\n      if (nonce === undefined || body === undefined) return { ok: false, failure: 'malformed' };\n      if (nonce.length !== NONCE_BYTES || body.length < TAG_BYTES) return { ok: false, failure: 'malformed' };\n      const counter = new DataView(view(nonce)).getBigUint64(NONCE_PREFIX_BYTES, false);\n      if (counter <= highestReceived) return { ok: false, failure: 'replay' };\n      let plaintext: ArrayBuffer;\n      try {\n        plaintext = await crypto.subtle.decrypt(\n          { name: CIPHER, iv: view(nonce), tagLength: TAG_BITS },\n          receiveKey,\n          view(body),\n        );\n      } catch {\n        // A failed tag means the message was altered in transit; there is no\n        // partial result worth salvaging.\n        return { ok: false, failure: 'auth' };\n      }\n      // Only after the tag verified, so a forged high counter cannot lock out\n      // every message that legitimately follows it.\n      highestReceived = counter;\n      return { ok: true, plaintext: new Uint8Array(plaintext) };\n    },\n  };\n}\n\n/**\n * Completes the handshake against the host key read out of the QR fragment.\n *\n * That key never travelled through the tunnel, which is what makes this\n * authenticated: a relay can watch the client's public key go past and learn\n * nothing, and it cannot substitute the host's because it never carried it.\n */\nexport async function connectSealedChannel(\n  hostPublicKey: string,\n): Promise<{ channel: SealedChannel; clientPublicKey: string } | undefined> {\n  if (globalThis.crypto?.subtle === undefined) return undefined;\n  try {\n    const pair = await crypto.subtle.generateKey(KEY_ALGORITHM, false, ['deriveBits']);\n    const hostKey = bytes(hostPublicKey);\n    if (hostKey === undefined) return undefined;\n    const peer = await crypto.subtle.importKey('raw', view(hostKey), KEY_ALGORITHM, false, []);\n    const secret = await crypto.subtle.deriveBits({ name: 'ECDH', public: peer }, pair.privateKey, KEY_BITS);\n    const clientPublicKey = base64Url(new Uint8Array(await crypto.subtle.exportKey('raw', pair.publicKey)));\n    return {\n      channel: channelFrom(\n        await derive(secret, 'c2s'),\n        await derive(secret, 's2c'),\n        new Uint8Array(NONCE_PREFIX_BYTES),\n      ),\n      clientPublicKey,\n    };\n  } catch {\n    // A malformed host key or a context without ECDH; the caller falls back to\n    // an unsealed channel and says so rather than failing silently.\n    return undefined;\n  }\n}\n\n/** Exposed so a test can build the browser side against a known secret. */\nexport async function channelFromSecret(\n  secret: ArrayBuffer,\n  sendDirection: SealedDirection,\n  noncePrefix: Uint8Array,\n): Promise<SealedChannel> {\n  const send = await derive(secret, sendDirection);\n  const receive = await derive(secret, sendDirection === 'c2s' ? 's2c' : 'c2s');\n  return channelFrom(send, receive, noncePrefix);\n}\n"],"mappings":"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"}

package/dist/adapters/bundleSigner.cjs

@@ -0,0 +1,2 @@
+const e=require("../_virtual/_rolldown/runtime.cjs"),t=require("../types/bundleManifest.cjs");let n=require("node:crypto"),r=require("node:fs");r=e.__toESM(r,1);let i=require("node:path");i=e.__toESM(i,1);const a=new Set([`.map`]);function o(e,t){let a=i.default.join(e,`signing.json`);try{let e=JSON.parse(r.default.readFileSync(a,`utf8`));if(typeof e==`object`&&e&&typeof e.privateKey==`string`&&typeof e.publicKey==`string`)return e;t(`the bundle signing key at ${a} is unreadable; generating a new one, so existing pins must be updated`)}catch{}let o=(0,n.generateKeyPairSync)(`ec`,{namedCurve:`prime256v1`,privateKeyEncoding:{type:`pkcs8`,format:`pem`},publicKeyEncoding:{type:`spki`,format:`der`}}),s={privateKey:o.privateKey,publicKey:Buffer.from(o.publicKey).toString(`base64url`)};try{r.default.mkdirSync(e,{recursive:!0,mode:448}),r.default.writeFileSync(a,`${JSON.stringify(s,void 0,2)}\n`,{mode:384})}catch(e){t(`the bundle signing key could not be saved: ${e instanceof Error?e.message:String(e)}`)}return s}function s(e,t,o){let c;try{c=r.default.readdirSync(t,{withFileTypes:!0})}catch{return}for(let l of c){let c=i.default.join(t,l.name);if(l.isDirectory()){s(e,c,o);continue}if(!(!l.isFile()||a.has(i.default.extname(l.name))))try{let t=r.default.readFileSync(c);o.push({path:`/${i.default.relative(e,c).split(i.default.sep).join(`/`)}`,sha256:(0,n.createHash)(`sha256`).update(t).digest(`hex`)})}catch{}}}function c(e,r=()=>{}){let i=o(e,r),a=(0,n.createPrivateKey)(i.privateKey),c=new Map;return{publicKey:()=>i.publicKey,sign(e){let r=c.get(e);if(r!==void 0||c.has(e))return r;let o=[];if(s(e,e,o),o.length===0){c.set(e,void 0);return}let l={version:1,builtAt:Date.now(),assets:o},u={manifest:l,signature:(0,n.createSign)(`sha256`).update(t.canonicalManifest(l)).sign({key:a,dsaEncoding:`ieee-p1363`}).toString(`base64url`),publicKey:i.publicKey};return c.set(e,u),u}}}function l(e){return Buffer.from((0,n.createPublicKey)(e).export({type:`spki`,format:`der`})).toString(`base64url`)}exports.createBundleSigner=c,exports.publicKeyOf=l;
+//# sourceMappingURL=bundleSigner.cjs.map

package/dist/adapters/bundleSigner.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleSigner.cjs","names":["path","fs","generateKeyPairSync","createHash","createPrivateKey","createSign","canonicalManifest","createPublicKey"],"sources":["../../src/adapters/bundleSigner.ts"],"sourcesContent":["import { createHash, createPrivateKey, createPublicKey, createSign, generateKeyPairSync } from 'node:crypto';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport {\n  BUNDLE_MANIFEST_VERSION,\n  type BundleAsset,\n  type BundleManifest,\n  type SignedBundleManifest,\n  canonicalManifest,\n} from '../types/bundleManifest.ts';\n\nconst SIGNING_FILE = 'signing.json';\nconst FILE_MODE = 0o600;\nconst DIRECTORY_MODE = 0o700;\n/** P-256 rather than Ed25519: universally available in WebCrypto, which Ed25519 is not yet. */\nconst CURVE = 'prime256v1';\nconst SIGN_ALGORITHM = 'sha256';\n/** Files a browser never fetches, so hashing them would only slow a rebuild. */\nconst SKIPPED = new Set(['.map']);\n\nexport interface BundleSigner {\n  /** Base64url SPKI for an independently trusted verifier to pin. */\n  publicKey(): string;\n  /** Hashes the asset tree and signs the result. Undefined when there is no bundle to sign. */\n  sign(assetsDir: string): SignedBundleManifest | undefined;\n}\n\ninterface StoredKey {\n  privateKey: string;\n  publicKey: string;\n}\n\n/**\n * Loads the hub's signing key, generating one on first run.\n *\n * Long-lived so an external verifier can pin it. Rotating the key invalidates\n * those pins, and losing the file has the same effect.\n */\nfunction loadKey(stateDir: string, onNotice: (message: string) => void): StoredKey {\n  const keyPath = path.join(stateDir, SIGNING_FILE);\n  try {\n    const parsed: unknown = JSON.parse(fs.readFileSync(keyPath, 'utf8'));\n    if (\n      typeof parsed === 'object' &&\n      parsed !== null &&\n      typeof (parsed as StoredKey).privateKey === 'string' &&\n      typeof (parsed as StoredKey).publicKey === 'string'\n    ) {\n      return parsed as StoredKey;\n    }\n    onNotice(\n      `the bundle signing key at ${keyPath} is unreadable; generating a new one, so existing pins must be updated`,\n    );\n  } catch {\n    // First run, which is the normal path and not worth a notice.\n  }\n  const pair = generateKeyPairSync('ec', {\n    namedCurve: CURVE,\n    privateKeyEncoding: { type: 'pkcs8', format: 'pem' },\n    publicKeyEncoding: { type: 'spki', format: 'der' },\n  });\n  const stored: StoredKey = {\n    privateKey: pair.privateKey,\n    publicKey: Buffer.from(pair.publicKey).toString('base64url'),\n  };\n  try {\n    fs.mkdirSync(stateDir, { recursive: true, mode: DIRECTORY_MODE });\n    fs.writeFileSync(keyPath, `${JSON.stringify(stored, undefined, 2)}\\n`, { mode: FILE_MODE });\n  } catch (error) {\n    onNotice(`the bundle signing key could not be saved: ${error instanceof Error ? error.message : String(error)}`);\n  }\n  return stored;\n}\n\n/** Every servable file under the asset root, as browser paths. */\nfunction walk(root: string, current: string, into: BundleAsset[]): void {\n  let entries: fs.Dirent[];\n  try {\n    entries = fs.readdirSync(current, { withFileTypes: true });\n  } catch {\n    return; // A directory that vanished mid-walk contributes nothing.\n  }\n  for (const entry of entries) {\n    const full = path.join(current, entry.name);\n    if (entry.isDirectory()) {\n      walk(root, full, into);\n      continue;\n    }\n    if (!entry.isFile() || SKIPPED.has(path.extname(entry.name))) continue;\n    try {\n      const bytes = fs.readFileSync(full);\n      into.push({\n        path: `/${path.relative(root, full).split(path.sep).join('/')}`,\n        sha256: createHash('sha256').update(bytes).digest('hex'),\n      });\n    } catch {\n      // Unreadable file; leaving it out of the manifest means it will fail\n      // verification, which is the right direction to be wrong in.\n    }\n  }\n}\n\nexport function createBundleSigner(stateDir: string, onNotice: (message: string) => void = () => {}): BundleSigner {\n  const key = loadKey(stateDir, onNotice);\n  const privateKey = createPrivateKey(key.privateKey);\n  /** Cached per asset directory: hashing a bundle is not free and it never changes under us mid-run. */\n  const cache = new Map<string, SignedBundleManifest | undefined>();\n\n  return {\n    publicKey: () => key.publicKey,\n\n    sign(assetsDir) {\n      const cached = cache.get(assetsDir);\n      if (cached !== undefined || cache.has(assetsDir)) return cached;\n      const assets: BundleAsset[] = [];\n      walk(assetsDir, assetsDir, assets);\n      if (assets.length === 0) {\n        cache.set(assetsDir, undefined);\n        return undefined;\n      }\n      const manifest: BundleManifest = { version: BUNDLE_MANIFEST_VERSION, builtAt: Date.now(), assets };\n      const signature = createSign(SIGN_ALGORITHM)\n        .update(canonicalManifest(manifest))\n        .sign({ key: privateKey, dsaEncoding: 'ieee-p1363' })\n        .toString('base64url');\n      const signed: SignedBundleManifest = { manifest, signature, publicKey: key.publicKey };\n      cache.set(assetsDir, signed);\n      return signed;\n    },\n  };\n}\n\n/** Re-derives the public key from a stored private key, for a test that wants to verify. */\nexport function publicKeyOf(privateKeyPem: string): string {\n  return Buffer.from(createPublicKey(privateKeyPem).export({ type: 'spki', format: 'der' }) as Buffer).toString(\n    'base64url',\n  );\n}\n"],"mappings":"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"}

package/dist/adapters/bundleSigner.d.cts

@@ -0,0 +1,14 @@
+import { SignedBundleManifest } from "../types/bundleManifest.cjs";
+//#region src/adapters/bundleSigner.d.ts
+interface BundleSigner {
+  /** Base64url SPKI for an independently trusted verifier to pin. */
+  publicKey(): string;
+  /** Hashes the asset tree and signs the result. Undefined when there is no bundle to sign. */
+  sign(assetsDir: string): SignedBundleManifest | undefined;
+}
+declare function createBundleSigner(stateDir: string, onNotice?: (message: string) => void): BundleSigner;
+/** Re-derives the public key from a stored private key, for a test that wants to verify. */
+declare function publicKeyOf(privateKeyPem: string): string;
+//#endregion
+export { BundleSigner, createBundleSigner, publicKeyOf };
+//# sourceMappingURL=bundleSigner.d.cts.map

package/dist/adapters/bundleSigner.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleSigner.d.cts","names":[],"sources":["../../src/adapters/bundleSigner.ts"],"mappings":";;UAoBiB;;EAEf;;EAEA,KAAK,oBAAoB;;iBA8EX,mBAAmB,kBAAkB,YAAW,2BAAsC;;iBA+BtF,YAAY"}

package/dist/adapters/bundleSigner.d.mts

@@ -0,0 +1,14 @@
+import { SignedBundleManifest } from "../types/bundleManifest.mjs";
+//#region src/adapters/bundleSigner.d.ts
+interface BundleSigner {
+  /** Base64url SPKI for an independently trusted verifier to pin. */
+  publicKey(): string;
+  /** Hashes the asset tree and signs the result. Undefined when there is no bundle to sign. */
+  sign(assetsDir: string): SignedBundleManifest | undefined;
+}
+declare function createBundleSigner(stateDir: string, onNotice?: (message: string) => void): BundleSigner;
+/** Re-derives the public key from a stored private key, for a test that wants to verify. */
+declare function publicKeyOf(privateKeyPem: string): string;
+//#endregion
+export { BundleSigner, createBundleSigner, publicKeyOf };
+//# sourceMappingURL=bundleSigner.d.mts.map

package/dist/adapters/bundleSigner.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleSigner.d.mts","names":[],"sources":["../../src/adapters/bundleSigner.ts"],"mappings":";;UAoBiB;;EAEf;;EAEA,KAAK,oBAAoB;;iBA8EX,mBAAmB,kBAAkB,YAAW,2BAAsC;;iBA+BtF,YAAY"}

package/dist/adapters/bundleSigner.mjs

@@ -0,0 +1,2 @@
+import{canonicalManifest as e}from"../types/bundleManifest.mjs";import{createHash as t,createPrivateKey as n,createPublicKey as r,createSign as i,generateKeyPairSync as a}from"node:crypto";import o from"node:fs";import s from"node:path";const c=new Set([`.map`]);function l(e,t){let n=s.join(e,`signing.json`);try{let e=JSON.parse(o.readFileSync(n,`utf8`));if(typeof e==`object`&&e&&typeof e.privateKey==`string`&&typeof e.publicKey==`string`)return e;t(`the bundle signing key at ${n} is unreadable; generating a new one, so existing pins must be updated`)}catch{}let r=a(`ec`,{namedCurve:`prime256v1`,privateKeyEncoding:{type:`pkcs8`,format:`pem`},publicKeyEncoding:{type:`spki`,format:`der`}}),i={privateKey:r.privateKey,publicKey:Buffer.from(r.publicKey).toString(`base64url`)};try{o.mkdirSync(e,{recursive:!0,mode:448}),o.writeFileSync(n,`${JSON.stringify(i,void 0,2)}\n`,{mode:384})}catch(e){t(`the bundle signing key could not be saved: ${e instanceof Error?e.message:String(e)}`)}return i}function u(e,n,r){let i;try{i=o.readdirSync(n,{withFileTypes:!0})}catch{return}for(let a of i){let i=s.join(n,a.name);if(a.isDirectory()){u(e,i,r);continue}if(!(!a.isFile()||c.has(s.extname(a.name))))try{let n=o.readFileSync(i);r.push({path:`/${s.relative(e,i).split(s.sep).join(`/`)}`,sha256:t(`sha256`).update(n).digest(`hex`)})}catch{}}}function d(t,r=()=>{}){let a=l(t,r),o=n(a.privateKey),s=new Map;return{publicKey:()=>a.publicKey,sign(t){let n=s.get(t);if(n!==void 0||s.has(t))return n;let r=[];if(u(t,t,r),r.length===0){s.set(t,void 0);return}let c={version:1,builtAt:Date.now(),assets:r},l={manifest:c,signature:i(`sha256`).update(e(c)).sign({key:o,dsaEncoding:`ieee-p1363`}).toString(`base64url`),publicKey:a.publicKey};return s.set(t,l),l}}}function f(e){return Buffer.from(r(e).export({type:`spki`,format:`der`})).toString(`base64url`)}export{d as createBundleSigner,f as publicKeyOf};
+//# sourceMappingURL=bundleSigner.mjs.map

package/dist/adapters/bundleSigner.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleSigner.mjs","names":[],"sources":["../../src/adapters/bundleSigner.ts"],"sourcesContent":["import { createHash, createPrivateKey, createPublicKey, createSign, generateKeyPairSync } from 'node:crypto';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport {\n  BUNDLE_MANIFEST_VERSION,\n  type BundleAsset,\n  type BundleManifest,\n  type SignedBundleManifest,\n  canonicalManifest,\n} from '../types/bundleManifest.ts';\n\nconst SIGNING_FILE = 'signing.json';\nconst FILE_MODE = 0o600;\nconst DIRECTORY_MODE = 0o700;\n/** P-256 rather than Ed25519: universally available in WebCrypto, which Ed25519 is not yet. */\nconst CURVE = 'prime256v1';\nconst SIGN_ALGORITHM = 'sha256';\n/** Files a browser never fetches, so hashing them would only slow a rebuild. */\nconst SKIPPED = new Set(['.map']);\n\nexport interface BundleSigner {\n  /** Base64url SPKI for an independently trusted verifier to pin. */\n  publicKey(): string;\n  /** Hashes the asset tree and signs the result. Undefined when there is no bundle to sign. */\n  sign(assetsDir: string): SignedBundleManifest | undefined;\n}\n\ninterface StoredKey {\n  privateKey: string;\n  publicKey: string;\n}\n\n/**\n * Loads the hub's signing key, generating one on first run.\n *\n * Long-lived so an external verifier can pin it. Rotating the key invalidates\n * those pins, and losing the file has the same effect.\n */\nfunction loadKey(stateDir: string, onNotice: (message: string) => void): StoredKey {\n  const keyPath = path.join(stateDir, SIGNING_FILE);\n  try {\n    const parsed: unknown = JSON.parse(fs.readFileSync(keyPath, 'utf8'));\n    if (\n      typeof parsed === 'object' &&\n      parsed !== null &&\n      typeof (parsed as StoredKey).privateKey === 'string' &&\n      typeof (parsed as StoredKey).publicKey === 'string'\n    ) {\n      return parsed as StoredKey;\n    }\n    onNotice(\n      `the bundle signing key at ${keyPath} is unreadable; generating a new one, so existing pins must be updated`,\n    );\n  } catch {\n    // First run, which is the normal path and not worth a notice.\n  }\n  const pair = generateKeyPairSync('ec', {\n    namedCurve: CURVE,\n    privateKeyEncoding: { type: 'pkcs8', format: 'pem' },\n    publicKeyEncoding: { type: 'spki', format: 'der' },\n  });\n  const stored: StoredKey = {\n    privateKey: pair.privateKey,\n    publicKey: Buffer.from(pair.publicKey).toString('base64url'),\n  };\n  try {\n    fs.mkdirSync(stateDir, { recursive: true, mode: DIRECTORY_MODE });\n    fs.writeFileSync(keyPath, `${JSON.stringify(stored, undefined, 2)}\\n`, { mode: FILE_MODE });\n  } catch (error) {\n    onNotice(`the bundle signing key could not be saved: ${error instanceof Error ? error.message : String(error)}`);\n  }\n  return stored;\n}\n\n/** Every servable file under the asset root, as browser paths. */\nfunction walk(root: string, current: string, into: BundleAsset[]): void {\n  let entries: fs.Dirent[];\n  try {\n    entries = fs.readdirSync(current, { withFileTypes: true });\n  } catch {\n    return; // A directory that vanished mid-walk contributes nothing.\n  }\n  for (const entry of entries) {\n    const full = path.join(current, entry.name);\n    if (entry.isDirectory()) {\n      walk(root, full, into);\n      continue;\n    }\n    if (!entry.isFile() || SKIPPED.has(path.extname(entry.name))) continue;\n    try {\n      const bytes = fs.readFileSync(full);\n      into.push({\n        path: `/${path.relative(root, full).split(path.sep).join('/')}`,\n        sha256: createHash('sha256').update(bytes).digest('hex'),\n      });\n    } catch {\n      // Unreadable file; leaving it out of the manifest means it will fail\n      // verification, which is the right direction to be wrong in.\n    }\n  }\n}\n\nexport function createBundleSigner(stateDir: string, onNotice: (message: string) => void = () => {}): BundleSigner {\n  const key = loadKey(stateDir, onNotice);\n  const privateKey = createPrivateKey(key.privateKey);\n  /** Cached per asset directory: hashing a bundle is not free and it never changes under us mid-run. */\n  const cache = new Map<string, SignedBundleManifest | undefined>();\n\n  return {\n    publicKey: () => key.publicKey,\n\n    sign(assetsDir) {\n      const cached = cache.get(assetsDir);\n      if (cached !== undefined || cache.has(assetsDir)) return cached;\n      const assets: BundleAsset[] = [];\n      walk(assetsDir, assetsDir, assets);\n      if (assets.length === 0) {\n        cache.set(assetsDir, undefined);\n        return undefined;\n      }\n      const manifest: BundleManifest = { version: BUNDLE_MANIFEST_VERSION, builtAt: Date.now(), assets };\n      const signature = createSign(SIGN_ALGORITHM)\n        .update(canonicalManifest(manifest))\n        .sign({ key: privateKey, dsaEncoding: 'ieee-p1363' })\n        .toString('base64url');\n      const signed: SignedBundleManifest = { manifest, signature, publicKey: key.publicKey };\n      cache.set(assetsDir, signed);\n      return signed;\n    },\n  };\n}\n\n/** Re-derives the public key from a stored private key, for a test that wants to verify. */\nexport function publicKeyOf(privateKeyPem: string): string {\n  return Buffer.from(createPublicKey(privateKeyPem).export({ type: 'spki', format: 'der' }) as Buffer).toString(\n    'base64url',\n  );\n}\n"],"mappings":"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"}

package/dist/adapters/nodeSealedChannel.cjs

@@ -0,0 +1,2 @@
+const e=require("../types/sealedChannel.cjs");let t=require("node:crypto");const n=`prime256v1`,r=`aes-256-gcm`,i=Buffer.from(`doompi/sealed/v1`);function a(n,r){return Buffer.from((0,t.hkdfSync)(`sha256`,n,i,Buffer.from(e.infoFor(r)),32))}function o(e,t){let n=Buffer.alloc(12);return e.copy(n,0,0,4),n.writeBigUInt64BE(t,4),n}function s(n,i,s){let c=a(n,i),l=a(n,i===`c2s`?`s2c`:`c2s`),u=0n,d=-1n;return{seal(n){if(u>=BigInt(e.MAX_MESSAGES_PER_KEY))return{ok:!1,failure:`exhausted`};let i=o(s,u),a=(0,t.createCipheriv)(r,c,i),l=Buffer.concat([a.update(n),a.final(),a.getAuthTag()]);return u+=1n,{ok:!0,envelope:{v:1,n:i.toString(`base64url`),c:l.toString(`base64url`)}}},open(n){let i=n;if(typeof i?.n!=`string`||typeof i.c!=`string`)return{ok:!1,failure:`malformed`};if(i.v!==1)return{ok:!1,failure:`version`};if(!e.isSealedEnvelope(n))return{ok:!1,failure:`malformed`};let a=Buffer.from(n.n,`base64url`),o=Buffer.from(n.c,`base64url`);if(a.length!==12||o.length<16)return{ok:!1,failure:`malformed`};let s=a.readBigUInt64BE(4);if(s<=d)return{ok:!1,failure:`replay`};let c=(0,t.createDecipheriv)(r,l,a);c.setAuthTag(o.subarray(o.length-16));let u;try{u=Buffer.concat([c.update(o.subarray(0,o.length-16)),c.final()])}catch{return{ok:!1,failure:`auth`}}return d=s,{ok:!0,plaintext:new Uint8Array(u)}}}}function c(){let e=(0,t.createECDH)(n);e.generateKeys();let r=new Set;return{publicKey:e.getPublicKey().toString(`base64url`),accept(i){let a,o;try{if(a=t.ECDH.convertKey(Buffer.from(i,`base64url`),n,void 0,void 0,`uncompressed`),r.has(a.toString(`base64url`)))return;o=e.computeSecret(a)}catch{return}return r.add(a.toString(`base64url`)),s(o,`s2c`,(0,t.randomBytes)(4))}}}exports.createHostHandshake=c;
+//# sourceMappingURL=nodeSealedChannel.cjs.map

package/dist/adapters/nodeSealedChannel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeSealedChannel.cjs","names":["hkdfSync","infoFor","MAX_MESSAGES_PER_KEY","createCipheriv","isSealedEnvelope","createDecipheriv","createECDH","ECDH","randomBytes"],"sources":["../../src/adapters/nodeSealedChannel.ts"],"sourcesContent":["import { ECDH, createCipheriv, createDecipheriv, createECDH, hkdfSync, randomBytes } from 'node:crypto';\nimport {\n  MAX_MESSAGES_PER_KEY,\n  NONCE_BYTES,\n  NONCE_PREFIX_BYTES,\n  SEALED_VERSION,\n  type SealedDirection,\n  type SealedEnvelope,\n  type SealedFailure,\n  infoFor,\n  isSealedEnvelope,\n} from '../types/sealedChannel.ts';\n\nconst CURVE = 'prime256v1';\nconst CIPHER = 'aes-256-gcm';\nconst KEY_BYTES = 32;\nconst TAG_BYTES = 16;\nconst HKDF_HASH = 'sha256';\n/** Fixed and public: HKDF's salt need not be secret, and a constant keeps both sides in step. */\nconst HKDF_SALT = Buffer.from('doompi/sealed/v1');\n\nexport type SealResult = { ok: true; envelope: SealedEnvelope } | { ok: false; failure: SealedFailure };\nexport type OpenResult = { ok: true; plaintext: Uint8Array } | { ok: false; failure: SealedFailure };\n\nexport interface SealedChannel {\n  /** Seals one message. Counters advance only on success. */\n  seal(plaintext: Uint8Array): SealResult;\n  open(envelope: unknown): OpenResult;\n}\n\nexport interface HostHandshake {\n  /** Base64url uncompressed P-256 point, printed in the QR. */\n  publicKey: string;\n  /** Completes the exchange against the peer's key and yields the channel. */\n  accept(peerPublicKey: string): SealedChannel | undefined;\n}\n\nfunction derive(secret: Buffer, direction: SealedDirection): Buffer {\n  return Buffer.from(hkdfSync(HKDF_HASH, secret, HKDF_SALT, Buffer.from(infoFor(direction)), KEY_BYTES));\n}\n\n/**\n * Builds the nonce for one message.\n *\n * A random per-channel prefix plus a monotonic counter, rather than a random\n * nonce per message: 96 bits is small enough that random nonces collide at a\n * rate worth caring about, and a repeated nonce under one AES-GCM key is\n * catastrophic rather than merely weak.\n */\nfunction nonceFor(prefix: Buffer, counter: bigint): Buffer {\n  const nonce = Buffer.alloc(NONCE_BYTES);\n  prefix.copy(nonce, 0, 0, NONCE_PREFIX_BYTES);\n  nonce.writeBigUInt64BE(counter, NONCE_PREFIX_BYTES);\n  return nonce;\n}\n\n/**\n * One direction's sealing state.\n *\n * Send and receive are separate keys and separate counters, so a message the\n * server sent can never be replayed back at it as though the client had sent it.\n */\nfunction createChannel(secret: Buffer, sendDirection: SealedDirection, noncePrefix: Buffer): SealedChannel {\n  const sendKey = derive(secret, sendDirection);\n  const receiveKey = derive(secret, sendDirection === 'c2s' ? 's2c' : 'c2s');\n  let sendCounter = 0n;\n  /** Strictly increasing: anything at or below what has been seen is a replay. */\n  let highestReceived = -1n;\n\n  return {\n    seal(plaintext) {\n      if (sendCounter >= BigInt(MAX_MESSAGES_PER_KEY)) return { ok: false, failure: 'exhausted' };\n      const nonce = nonceFor(noncePrefix, sendCounter);\n      const cipher = createCipheriv(CIPHER, sendKey, nonce);\n      const body = Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()]);\n      sendCounter += 1n;\n      return {\n        ok: true,\n        envelope: { v: SEALED_VERSION, n: nonce.toString('base64url'), c: body.toString('base64url') },\n      };\n    },\n\n    open(envelope) {\n      // Shape before version: something with no `v` at all is malformed, and\n      // calling it a version mismatch would send a reader hunting for a\n      // protocol skew that is not there.\n      const shape = envelope as { v?: unknown; n?: unknown; c?: unknown } | null | undefined;\n      if (typeof shape?.n !== 'string' || typeof shape.c !== 'string') return { ok: false, failure: 'malformed' };\n      if (shape.v !== SEALED_VERSION) return { ok: false, failure: 'version' };\n      if (!isSealedEnvelope(envelope)) return { ok: false, failure: 'malformed' };\n      const nonce = Buffer.from(envelope.n, 'base64url');\n      const body = Buffer.from(envelope.c, 'base64url');\n      if (nonce.length !== NONCE_BYTES || body.length < TAG_BYTES) return { ok: false, failure: 'malformed' };\n      const counter = nonce.readBigUInt64BE(NONCE_PREFIX_BYTES);\n      if (counter <= highestReceived) return { ok: false, failure: 'replay' };\n      const decipher = createDecipheriv(CIPHER, receiveKey, nonce);\n      decipher.setAuthTag(body.subarray(body.length - TAG_BYTES));\n      let plaintext: Buffer;\n      try {\n        plaintext = Buffer.concat([decipher.update(body.subarray(0, body.length - TAG_BYTES)), decipher.final()]);\n      } catch {\n        // A failed tag means the message was altered, which is the whole point\n        // of having one. Never fall back to the ciphertext.\n        return { ok: false, failure: 'auth' };\n      }\n      // Advanced only after the tag verified, so a forged high counter cannot\n      // lock out the messages that follow it.\n      highestReceived = counter;\n      return { ok: true, plaintext: new Uint8Array(plaintext) };\n    },\n  };\n}\n\n/**\n * The host half of the handshake.\n *\n * The ephemeral key pair is generated per tunnel and its public half goes in the\n * QR, which is the out-of-band channel that makes this authenticated. A relay\n * that swaps the client's key gets a channel with itself and nothing from the\n * host, because the host only ever derives against the key the client presents\n * and the client only ever derives against the key it read off the screen.\n */\nexport function createHostHandshake(): HostHandshake {\n  const exchange = createECDH(CURVE);\n  exchange.generateKeys();\n  const acceptedPeers = new Set<string>();\n  return {\n    publicKey: exchange.getPublicKey().toString('base64url'),\n    accept(peerPublicKey) {\n      let peer: Buffer;\n      let secret: Buffer;\n      try {\n        peer = ECDH.convertKey(Buffer.from(peerPublicKey, 'base64url'), CURVE, undefined, undefined, 'uncompressed');\n        if (acceptedPeers.has(peer.toString('base64url'))) return undefined;\n        secret = exchange.computeSecret(peer);\n      } catch {\n        // A key that is not a point on the curve; there is no channel to make.\n        return undefined;\n      }\n      acceptedPeers.add(peer.toString('base64url'));\n      // The prefix is the host's to choose and travels in every nonce, so the\n      // client reads it off the wire rather than needing it up front.\n      return createChannel(secret, 's2c', randomBytes(NONCE_PREFIX_BYTES));\n    },\n  };\n}\n"],"mappings":"2EAaA,MAAM,EAAQ,aACR,EAAS,cAKT,EAAY,OAAO,KAAK,kBAAkB,EAkBhD,SAAS,EAAO,EAAgB,EAAoC,CAClE,OAAO,OAAO,MAAA,EAAKA,EAAAA,SAAAA,CAAS,SAAW,EAAQ,EAAW,OAAO,KAAKC,EAAAA,QAAQ,CAAS,CAAC,EAAG,EAAS,CAAC,CACvG,CAUA,SAAS,EAAS,EAAgB,EAAyB,CACzD,IAAM,EAAQ,OAAO,MAAA,EAAiB,EAGtC,OAFA,EAAO,KAAK,EAAO,EAAG,EAAA,CAAqB,EAC3C,EAAM,iBAAiB,EAAA,CAA2B,EAC3C,CACT,CAQA,SAAS,EAAc,EAAgB,EAAgC,EAAoC,CACzG,IAAM,EAAU,EAAO,EAAQ,CAAa,EACtC,EAAa,EAAO,EAAQ,IAAkB,MAAQ,MAAQ,KAAK,EACrE,EAAc,GAEd,EAAkB,CAAC,GAEvB,MAAO,CACL,KAAK,EAAW,CACd,GAAI,GAAe,OAAOC,EAAAA,oBAAoB,EAAG,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EAC1F,IAAM,EAAQ,EAAS,EAAa,CAAW,EACzC,GAAA,EAASC,EAAAA,eAAAA,CAAe,EAAQ,EAAS,CAAK,EAC9C,EAAO,OAAO,OAAO,CAAC,EAAO,OAAO,CAAS,EAAG,EAAO,MAAM,EAAG,EAAO,WAAW,CAAC,CAAC,EAE1F,MADA,IAAe,GACR,CACL,GAAI,GACJ,SAAU,CAAE,EAAA,EAAmB,EAAG,EAAM,SAAS,WAAW,EAAG,EAAG,EAAK,SAAS,WAAW,CAAE,CAC/F,CACF,EAEA,KAAK,EAAU,CAIb,IAAM,EAAQ,EACd,GAAI,OAAO,GAAO,GAAM,UAAY,OAAO,EAAM,GAAM,SAAU,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EAC1G,GAAI,EAAM,IAAA,EAAsB,MAAO,CAAE,GAAI,GAAO,QAAS,SAAU,EACvE,GAAI,CAACC,EAAAA,iBAAiB,CAAQ,EAAG,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EAC1E,IAAM,EAAQ,OAAO,KAAK,EAAS,EAAG,WAAW,EAC3C,EAAO,OAAO,KAAK,EAAS,EAAG,WAAW,EAChD,GAAI,EAAM,SAAA,IAA0B,EAAK,OAAS,GAAW,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EACtG,IAAM,EAAU,EAAM,gBAAA,CAAkC,EACxD,GAAI,GAAW,EAAiB,MAAO,CAAE,GAAI,GAAO,QAAS,QAAS,EACtE,IAAM,GAAA,EAAWC,EAAAA,iBAAAA,CAAiB,EAAQ,EAAY,CAAK,EAC3D,EAAS,WAAW,EAAK,SAAS,EAAK,OAAS,EAAS,CAAC,EAC1D,IAAI,EACJ,GAAI,CACF,EAAY,OAAO,OAAO,CAAC,EAAS,OAAO,EAAK,SAAS,EAAG,EAAK,OAAS,EAAS,CAAC,EAAG,EAAS,MAAM,CAAC,CAAC,CAC1G,MAAQ,CAGN,MAAO,CAAE,GAAI,GAAO,QAAS,MAAO,CACtC,CAIA,MADA,GAAkB,EACX,CAAE,GAAI,GAAM,UAAW,IAAI,WAAW,CAAS,CAAE,CAC1D,CACF,CACF,CAWA,SAAgB,GAAqC,CACnD,IAAM,GAAA,EAAWC,EAAAA,WAAAA,CAAW,CAAK,EACjC,EAAS,aAAa,EACtB,IAAM,EAAgB,IAAI,IAC1B,MAAO,CACL,UAAW,EAAS,aAAa,CAAC,CAAC,SAAS,WAAW,EACvD,OAAO,EAAe,CACpB,IAAI,EACA,EACJ,GAAI,CAEF,GADA,EAAOC,EAAAA,KAAK,WAAW,OAAO,KAAK,EAAe,WAAW,EAAG,EAAO,IAAA,GAAW,IAAA,GAAW,cAAc,EACvG,EAAc,IAAI,EAAK,SAAS,WAAW,CAAC,EAAG,OACnD,EAAS,EAAS,cAAc,CAAI,CACtC,MAAQ,CAEN,MACF,CAIA,OAHA,EAAc,IAAI,EAAK,SAAS,WAAW,CAAC,EAGrC,EAAc,EAAQ,OAAA,EAAOC,EAAAA,YAAAA,CAAAA,CAA8B,CAAC,CACrE,CACF,CACF"}

package/dist/adapters/nodeSealedChannel.d.cts

@@ -0,0 +1,40 @@
+import { SealedEnvelope, SealedFailure } from "../types/sealedChannel.cjs";
+//#region src/adapters/nodeSealedChannel.d.ts
+type SealResult = {
+  ok: true;
+  envelope: SealedEnvelope;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+type OpenResult = {
+  ok: true;
+  plaintext: Uint8Array;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+interface SealedChannel {
+  /** Seals one message. Counters advance only on success. */
+  seal(plaintext: Uint8Array): SealResult;
+  open(envelope: unknown): OpenResult;
+}
+interface HostHandshake {
+  /** Base64url uncompressed P-256 point, printed in the QR. */
+  publicKey: string;
+  /** Completes the exchange against the peer's key and yields the channel. */
+  accept(peerPublicKey: string): SealedChannel | undefined;
+}
+/**
+ * The host half of the handshake.
+ *
+ * The ephemeral key pair is generated per tunnel and its public half goes in the
+ * QR, which is the out-of-band channel that makes this authenticated. A relay
+ * that swaps the client's key gets a channel with itself and nothing from the
+ * host, because the host only ever derives against the key the client presents
+ * and the client only ever derives against the key it read off the screen.
+ */
+declare function createHostHandshake(): HostHandshake;
+//#endregion
+export { HostHandshake, OpenResult, SealResult, SealedChannel, createHostHandshake };
+//# sourceMappingURL=nodeSealedChannel.d.cts.map

package/dist/adapters/nodeSealedChannel.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeSealedChannel.d.cts","names":[],"sources":["../../src/adapters/nodeSealedChannel.ts"],"mappings":";;KAqBY;EAAe;EAAU,UAAU;;EAAqB;EAAW,SAAS;;KAC5E;EAAe;EAAU,WAAW;;EAAiB;EAAW,SAAS;;UAEpE;;EAEf,KAAK,WAAW,aAAa;EAC7B,KAAK,oBAAoB;;UAGV;;EAEf;;EAEA,OAAO,wBAAwB;;;;;;;;;;;iBAwFjB,uBAAuB"}

package/dist/adapters/nodeSealedChannel.d.mts

@@ -0,0 +1,40 @@
+import { SealedEnvelope, SealedFailure } from "../types/sealedChannel.mjs";
+//#region src/adapters/nodeSealedChannel.d.ts
+type SealResult = {
+  ok: true;
+  envelope: SealedEnvelope;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+type OpenResult = {
+  ok: true;
+  plaintext: Uint8Array;
+} | {
+  ok: false;
+  failure: SealedFailure;
+};
+interface SealedChannel {
+  /** Seals one message. Counters advance only on success. */
+  seal(plaintext: Uint8Array): SealResult;
+  open(envelope: unknown): OpenResult;
+}
+interface HostHandshake {
+  /** Base64url uncompressed P-256 point, printed in the QR. */
+  publicKey: string;
+  /** Completes the exchange against the peer's key and yields the channel. */
+  accept(peerPublicKey: string): SealedChannel | undefined;
+}
+/**
+ * The host half of the handshake.
+ *
+ * The ephemeral key pair is generated per tunnel and its public half goes in the
+ * QR, which is the out-of-band channel that makes this authenticated. A relay
+ * that swaps the client's key gets a channel with itself and nothing from the
+ * host, because the host only ever derives against the key the client presents
+ * and the client only ever derives against the key it read off the screen.
+ */
+declare function createHostHandshake(): HostHandshake;
+//#endregion
+export { HostHandshake, OpenResult, SealResult, SealedChannel, createHostHandshake };
+//# sourceMappingURL=nodeSealedChannel.d.mts.map

package/dist/adapters/nodeSealedChannel.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeSealedChannel.d.mts","names":[],"sources":["../../src/adapters/nodeSealedChannel.ts"],"mappings":";;KAqBY;EAAe;EAAU,UAAU;;EAAqB;EAAW,SAAS;;KAC5E;EAAe;EAAU,WAAW;;EAAiB;EAAW,SAAS;;UAEpE;;EAEf,KAAK,WAAW,aAAa;EAC7B,KAAK,oBAAoB;;UAGV;;EAEf;;EAEA,OAAO,wBAAwB;;;;;;;;;;;iBAwFjB,uBAAuB"}

package/dist/adapters/nodeSealedChannel.mjs

@@ -0,0 +1,2 @@
+import{MAX_MESSAGES_PER_KEY as e,infoFor as t,isSealedEnvelope as n}from"../types/sealedChannel.mjs";import{ECDH as r,createCipheriv as i,createDecipheriv as a,createECDH as o,hkdfSync as s,randomBytes as c}from"node:crypto";const l=`prime256v1`,u=`aes-256-gcm`,d=Buffer.from(`doompi/sealed/v1`);function f(e,n){return Buffer.from(s(`sha256`,e,d,Buffer.from(t(n)),32))}function p(e,t){let n=Buffer.alloc(12);return e.copy(n,0,0,4),n.writeBigUInt64BE(t,4),n}function m(t,r,o){let s=f(t,r),c=f(t,r===`c2s`?`s2c`:`c2s`),l=0n,d=-1n;return{seal(t){if(l>=BigInt(e))return{ok:!1,failure:`exhausted`};let n=p(o,l),r=i(u,s,n),a=Buffer.concat([r.update(t),r.final(),r.getAuthTag()]);return l+=1n,{ok:!0,envelope:{v:1,n:n.toString(`base64url`),c:a.toString(`base64url`)}}},open(e){let t=e;if(typeof t?.n!=`string`||typeof t.c!=`string`)return{ok:!1,failure:`malformed`};if(t.v!==1)return{ok:!1,failure:`version`};if(!n(e))return{ok:!1,failure:`malformed`};let r=Buffer.from(e.n,`base64url`),i=Buffer.from(e.c,`base64url`);if(r.length!==12||i.length<16)return{ok:!1,failure:`malformed`};let o=r.readBigUInt64BE(4);if(o<=d)return{ok:!1,failure:`replay`};let s=a(u,c,r);s.setAuthTag(i.subarray(i.length-16));let l;try{l=Buffer.concat([s.update(i.subarray(0,i.length-16)),s.final()])}catch{return{ok:!1,failure:`auth`}}return d=o,{ok:!0,plaintext:new Uint8Array(l)}}}}function h(){let e=o(l);e.generateKeys();let t=new Set;return{publicKey:e.getPublicKey().toString(`base64url`),accept(n){let i,a;try{if(i=r.convertKey(Buffer.from(n,`base64url`),l,void 0,void 0,`uncompressed`),t.has(i.toString(`base64url`)))return;a=e.computeSecret(i)}catch{return}return t.add(i.toString(`base64url`)),m(a,`s2c`,c(4))}}}export{h as createHostHandshake};
+//# sourceMappingURL=nodeSealedChannel.mjs.map

package/dist/adapters/nodeSealedChannel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeSealedChannel.mjs","names":[],"sources":["../../src/adapters/nodeSealedChannel.ts"],"sourcesContent":["import { ECDH, createCipheriv, createDecipheriv, createECDH, hkdfSync, randomBytes } from 'node:crypto';\nimport {\n  MAX_MESSAGES_PER_KEY,\n  NONCE_BYTES,\n  NONCE_PREFIX_BYTES,\n  SEALED_VERSION,\n  type SealedDirection,\n  type SealedEnvelope,\n  type SealedFailure,\n  infoFor,\n  isSealedEnvelope,\n} from '../types/sealedChannel.ts';\n\nconst CURVE = 'prime256v1';\nconst CIPHER = 'aes-256-gcm';\nconst KEY_BYTES = 32;\nconst TAG_BYTES = 16;\nconst HKDF_HASH = 'sha256';\n/** Fixed and public: HKDF's salt need not be secret, and a constant keeps both sides in step. */\nconst HKDF_SALT = Buffer.from('doompi/sealed/v1');\n\nexport type SealResult = { ok: true; envelope: SealedEnvelope } | { ok: false; failure: SealedFailure };\nexport type OpenResult = { ok: true; plaintext: Uint8Array } | { ok: false; failure: SealedFailure };\n\nexport interface SealedChannel {\n  /** Seals one message. Counters advance only on success. */\n  seal(plaintext: Uint8Array): SealResult;\n  open(envelope: unknown): OpenResult;\n}\n\nexport interface HostHandshake {\n  /** Base64url uncompressed P-256 point, printed in the QR. */\n  publicKey: string;\n  /** Completes the exchange against the peer's key and yields the channel. */\n  accept(peerPublicKey: string): SealedChannel | undefined;\n}\n\nfunction derive(secret: Buffer, direction: SealedDirection): Buffer {\n  return Buffer.from(hkdfSync(HKDF_HASH, secret, HKDF_SALT, Buffer.from(infoFor(direction)), KEY_BYTES));\n}\n\n/**\n * Builds the nonce for one message.\n *\n * A random per-channel prefix plus a monotonic counter, rather than a random\n * nonce per message: 96 bits is small enough that random nonces collide at a\n * rate worth caring about, and a repeated nonce under one AES-GCM key is\n * catastrophic rather than merely weak.\n */\nfunction nonceFor(prefix: Buffer, counter: bigint): Buffer {\n  const nonce = Buffer.alloc(NONCE_BYTES);\n  prefix.copy(nonce, 0, 0, NONCE_PREFIX_BYTES);\n  nonce.writeBigUInt64BE(counter, NONCE_PREFIX_BYTES);\n  return nonce;\n}\n\n/**\n * One direction's sealing state.\n *\n * Send and receive are separate keys and separate counters, so a message the\n * server sent can never be replayed back at it as though the client had sent it.\n */\nfunction createChannel(secret: Buffer, sendDirection: SealedDirection, noncePrefix: Buffer): SealedChannel {\n  const sendKey = derive(secret, sendDirection);\n  const receiveKey = derive(secret, sendDirection === 'c2s' ? 's2c' : 'c2s');\n  let sendCounter = 0n;\n  /** Strictly increasing: anything at or below what has been seen is a replay. */\n  let highestReceived = -1n;\n\n  return {\n    seal(plaintext) {\n      if (sendCounter >= BigInt(MAX_MESSAGES_PER_KEY)) return { ok: false, failure: 'exhausted' };\n      const nonce = nonceFor(noncePrefix, sendCounter);\n      const cipher = createCipheriv(CIPHER, sendKey, nonce);\n      const body = Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()]);\n      sendCounter += 1n;\n      return {\n        ok: true,\n        envelope: { v: SEALED_VERSION, n: nonce.toString('base64url'), c: body.toString('base64url') },\n      };\n    },\n\n    open(envelope) {\n      // Shape before version: something with no `v` at all is malformed, and\n      // calling it a version mismatch would send a reader hunting for a\n      // protocol skew that is not there.\n      const shape = envelope as { v?: unknown; n?: unknown; c?: unknown } | null | undefined;\n      if (typeof shape?.n !== 'string' || typeof shape.c !== 'string') return { ok: false, failure: 'malformed' };\n      if (shape.v !== SEALED_VERSION) return { ok: false, failure: 'version' };\n      if (!isSealedEnvelope(envelope)) return { ok: false, failure: 'malformed' };\n      const nonce = Buffer.from(envelope.n, 'base64url');\n      const body = Buffer.from(envelope.c, 'base64url');\n      if (nonce.length !== NONCE_BYTES || body.length < TAG_BYTES) return { ok: false, failure: 'malformed' };\n      const counter = nonce.readBigUInt64BE(NONCE_PREFIX_BYTES);\n      if (counter <= highestReceived) return { ok: false, failure: 'replay' };\n      const decipher = createDecipheriv(CIPHER, receiveKey, nonce);\n      decipher.setAuthTag(body.subarray(body.length - TAG_BYTES));\n      let plaintext: Buffer;\n      try {\n        plaintext = Buffer.concat([decipher.update(body.subarray(0, body.length - TAG_BYTES)), decipher.final()]);\n      } catch {\n        // A failed tag means the message was altered, which is the whole point\n        // of having one. Never fall back to the ciphertext.\n        return { ok: false, failure: 'auth' };\n      }\n      // Advanced only after the tag verified, so a forged high counter cannot\n      // lock out the messages that follow it.\n      highestReceived = counter;\n      return { ok: true, plaintext: new Uint8Array(plaintext) };\n    },\n  };\n}\n\n/**\n * The host half of the handshake.\n *\n * The ephemeral key pair is generated per tunnel and its public half goes in the\n * QR, which is the out-of-band channel that makes this authenticated. A relay\n * that swaps the client's key gets a channel with itself and nothing from the\n * host, because the host only ever derives against the key the client presents\n * and the client only ever derives against the key it read off the screen.\n */\nexport function createHostHandshake(): HostHandshake {\n  const exchange = createECDH(CURVE);\n  exchange.generateKeys();\n  const acceptedPeers = new Set<string>();\n  return {\n    publicKey: exchange.getPublicKey().toString('base64url'),\n    accept(peerPublicKey) {\n      let peer: Buffer;\n      let secret: Buffer;\n      try {\n        peer = ECDH.convertKey(Buffer.from(peerPublicKey, 'base64url'), CURVE, undefined, undefined, 'uncompressed');\n        if (acceptedPeers.has(peer.toString('base64url'))) return undefined;\n        secret = exchange.computeSecret(peer);\n      } catch {\n        // A key that is not a point on the curve; there is no channel to make.\n        return undefined;\n      }\n      acceptedPeers.add(peer.toString('base64url'));\n      // The prefix is the host's to choose and travels in every nonce, so the\n      // client reads it off the wire rather than needing it up front.\n      return createChannel(secret, 's2c', randomBytes(NONCE_PREFIX_BYTES));\n    },\n  };\n}\n"],"mappings":"iOAaA,MAAM,EAAQ,aACR,EAAS,cAKT,EAAY,OAAO,KAAK,kBAAkB,EAkBhD,SAAS,EAAO,EAAgB,EAAoC,CAClE,OAAO,OAAO,KAAK,EAAS,SAAW,EAAQ,EAAW,OAAO,KAAK,EAAQ,CAAS,CAAC,EAAG,EAAS,CAAC,CACvG,CAUA,SAAS,EAAS,EAAgB,EAAyB,CACzD,IAAM,EAAQ,OAAO,MAAA,EAAiB,EAGtC,OAFA,EAAO,KAAK,EAAO,EAAG,EAAA,CAAqB,EAC3C,EAAM,iBAAiB,EAAA,CAA2B,EAC3C,CACT,CAQA,SAAS,EAAc,EAAgB,EAAgC,EAAoC,CACzG,IAAM,EAAU,EAAO,EAAQ,CAAa,EACtC,EAAa,EAAO,EAAQ,IAAkB,MAAQ,MAAQ,KAAK,EACrE,EAAc,GAEd,EAAkB,CAAC,GAEvB,MAAO,CACL,KAAK,EAAW,CACd,GAAI,GAAe,OAAO,CAAoB,EAAG,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EAC1F,IAAM,EAAQ,EAAS,EAAa,CAAW,EACzC,EAAS,EAAe,EAAQ,EAAS,CAAK,EAC9C,EAAO,OAAO,OAAO,CAAC,EAAO,OAAO,CAAS,EAAG,EAAO,MAAM,EAAG,EAAO,WAAW,CAAC,CAAC,EAE1F,MADA,IAAe,GACR,CACL,GAAI,GACJ,SAAU,CAAE,EAAA,EAAmB,EAAG,EAAM,SAAS,WAAW,EAAG,EAAG,EAAK,SAAS,WAAW,CAAE,CAC/F,CACF,EAEA,KAAK,EAAU,CAIb,IAAM,EAAQ,EACd,GAAI,OAAO,GAAO,GAAM,UAAY,OAAO,EAAM,GAAM,SAAU,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EAC1G,GAAI,EAAM,IAAA,EAAsB,MAAO,CAAE,GAAI,GAAO,QAAS,SAAU,EACvE,GAAI,CAAC,EAAiB,CAAQ,EAAG,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EAC1E,IAAM,EAAQ,OAAO,KAAK,EAAS,EAAG,WAAW,EAC3C,EAAO,OAAO,KAAK,EAAS,EAAG,WAAW,EAChD,GAAI,EAAM,SAAA,IAA0B,EAAK,OAAS,GAAW,MAAO,CAAE,GAAI,GAAO,QAAS,WAAY,EACtG,IAAM,EAAU,EAAM,gBAAA,CAAkC,EACxD,GAAI,GAAW,EAAiB,MAAO,CAAE,GAAI,GAAO,QAAS,QAAS,EACtE,IAAM,EAAW,EAAiB,EAAQ,EAAY,CAAK,EAC3D,EAAS,WAAW,EAAK,SAAS,EAAK,OAAS,EAAS,CAAC,EAC1D,IAAI,EACJ,GAAI,CACF,EAAY,OAAO,OAAO,CAAC,EAAS,OAAO,EAAK,SAAS,EAAG,EAAK,OAAS,EAAS,CAAC,EAAG,EAAS,MAAM,CAAC,CAAC,CAC1G,MAAQ,CAGN,MAAO,CAAE,GAAI,GAAO,QAAS,MAAO,CACtC,CAIA,MADA,GAAkB,EACX,CAAE,GAAI,GAAM,UAAW,IAAI,WAAW,CAAS,CAAE,CAC1D,CACF,CACF,CAWA,SAAgB,GAAqC,CACnD,IAAM,EAAW,EAAW,CAAK,EACjC,EAAS,aAAa,EACtB,IAAM,EAAgB,IAAI,IAC1B,MAAO,CACL,UAAW,EAAS,aAAa,CAAC,CAAC,SAAS,WAAW,EACvD,OAAO,EAAe,CACpB,IAAI,EACA,EACJ,GAAI,CAEF,GADA,EAAO,EAAK,WAAW,OAAO,KAAK,EAAe,WAAW,EAAG,EAAO,IAAA,GAAW,IAAA,GAAW,cAAc,EACvG,EAAc,IAAI,EAAK,SAAS,WAAW,CAAC,EAAG,OACnD,EAAS,EAAS,cAAc,CAAI,CACtC,MAAQ,CAEN,MACF,CAIA,OAHA,EAAc,IAAI,EAAK,SAAS,WAAW,CAAC,EAGrC,EAAc,EAAQ,MAAO,EAAA,CAA8B,CAAC,CACrE,CACF,CACF"}

package/dist/adapters/sealedTransport.cjs

@@ -0,0 +1,2 @@
+const e=require("../types/sealedChannel.cjs"),t=require("./browserSealedChannel.cjs"),n=require("../services/serialQueue.cjs"),r=new TextEncoder,i=new TextDecoder;function a(e){let t=``;for(let n of e)t+=String.fromCharCode(n);return btoa(t)}function o(e){let t=atob(e);return Uint8Array.from(t,e=>e.charCodeAt(0))}async function s(e){if(e!=null){if(typeof e==`string`)return r.encode(e);if(e instanceof URLSearchParams)return r.encode(e.toString());if(e instanceof Blob)return new Uint8Array(await e.arrayBuffer());if(e instanceof ArrayBuffer)return new Uint8Array(e);if(ArrayBuffer.isView(e))return new Uint8Array(e.buffer,e.byteOffset,e.byteLength);throw Error(`The sealed HTTP transport does not support this request body type.`)}}function c(e){if(!e.startsWith(`/`))throw Error(`A sealed HTTP request must use a root-relative URL.`);return e}function l(e){if(typeof e!=`object`||!e)return!1;let t=e;return t.v===1&&typeof t.status==`number`&&Array.isArray(t.headers)&&t.headers.every(e=>Array.isArray(e)&&e.length===2&&e.every(e=>typeof e==`string`))&&typeof t.body==`string`}function u(){let u,d,f=n.createSerialQueue(),p=n.createSerialQueue(),m=n.createSerialQueue(),h,g=t=>{d=e.describeSealedFailure(t)},_=async e=>{if(u===void 0)return;let t=await u.seal(e);return t.ok?JSON.stringify(t.envelope):g(t.failure)},v=async e=>{if(u===void 0)return;let t;try{t=JSON.parse(e)}catch{return g(`malformed`)}let n=await u.open(t);return n.ok?n.plaintext:g(n.failure)};return{active:()=>u!==void 0,lastFailure:()=>d,async connect(e){let n=await t.connectSealedChannel(e);if(n===void 0){d=`This browser could not establish a sealed channel.`;return}return u=n.channel,d=void 0,n.clientPublicKey},relayRequestsThrough(e){h=e},reset(){u=void 0,d=void 0},async sealText(e){return u===void 0?e:await f.run(async()=>{let t=await _(r.encode(e));if(t===void 0)throw Error(d??`The active sealed channel could not encrypt a message.`);return t})},async openText(e){return u===void 0?e:await p.run(async()=>{let t=await v(e);return t===void 0?void 0:i.decode(t)})},async sealBinary(e){return u===void 0?e:await f.run(async()=>{let t=await _(e);if(t===void 0)throw Error(d??`The active sealed channel could not encrypt a message.`);return r.encode(t)})},async openBinary(e){return u===void 0?e:await p.run(async()=>await v(i.decode(e)))},async fetch(e,t){let n=h;return u===void 0||n===void 0?await fetch(e,t):await m.run(async()=>{let u=await s(t?.body),f={v:1,method:(t?.method??`GET`).toUpperCase(),target:c(e),headers:Array.from(new Headers(t?.headers).entries()),...u===void 0?{}:{body:a(u)}},p=await _(r.encode(JSON.stringify(f)));if(p===void 0)return new Response(JSON.stringify({error:d}),{status:502});let m=await fetch(n,{method:`POST`,credentials:`same-origin`,headers:{"content-type":`application/json`},body:p}),h=await v(await m.text());if(h===void 0)return new Response(JSON.stringify({error:d}),{status:502});let g;try{g=JSON.parse(i.decode(h))}catch{g=void 0}if(!l(g))return d=`The sealed HTTP response was malformed.`,new Response(JSON.stringify({error:d}),{status:502});let y=o(g.body);return new Response(g.status===204||g.status===205||g.status===304?null:y,{status:g.status,headers:g.headers})})}}}const d=u();exports.createSealedTransport=u,exports.sealedTransport=d;
+//# sourceMappingURL=sealedTransport.cjs.map

package/dist/adapters/sealedTransport.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sealedTransport.cjs","names":["createSerialQueue","describeSealedFailure","connectSealedChannel"],"sources":["../../src/adapters/sealedTransport.ts"],"sourcesContent":["import { createSerialQueue } from '../services/serialQueue.ts';\nimport { describeSealedFailure, type SealedFailure } from '../types/sealedChannel.ts';\nimport { connectSealedChannel, type SealedChannel } from './browserSealedChannel.ts';\n\n/**\n * The one object the cockpit and every plugin use to talk over a sealed tunnel.\n *\n * Two things make this worth having rather than each caller reaching for the\n * channel directly. First, ordering: sealing advances a nonce counter and\n * opening enforces that it strictly increases, so both directions are pushed\n * through a serial queue and overlapping calls can never reorder into a\n * self-inflicted replay. Second, reach: a plugin that calls `fetch` itself\n * sends plaintext to whoever is relaying the tunnel, and the host cannot stop\n * it. Giving every caller one obvious helper is the only enforcement available.\n *\n * When no channel is established every method is a pass-through, so the same\n * code runs unchanged on the loopback listener where there is nothing to seal.\n */\n\nconst JSON_CONTENT_TYPE = 'application/json';\n\nexport interface SealedTransport {\n  /** False on loopback and before the handshake completes, where everything passes through. */\n  active(): boolean;\n  sealText(text: string): Promise<string>;\n  /** Undefined when the message could not be opened; `lastFailure` says why. */\n  openText(text: string): Promise<string | undefined>;\n  sealBinary(bytes: Uint8Array): Promise<Uint8Array>;\n  openBinary(bytes: Uint8Array): Promise<Uint8Array | undefined>;\n  /** Drop-in for `fetch`, relaying the complete request through the sealed channel when configured. */\n  fetch(input: string, init?: RequestInit): Promise<Response>;\n  lastFailure(): string | undefined;\n}\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\ninterface SealedHttpRequest {\n  v: 1;\n  method: string;\n  target: string;\n  headers: Array<[string, string]>;\n  body?: string;\n}\n\ninterface SealedHttpResponse {\n  v: 1;\n  status: number;\n  headers: Array<[string, string]>;\n  body: string;\n}\n\nfunction encodeBase64(bytes: Uint8Array): string {\n  let binary = '';\n  for (const byte of bytes) binary += String.fromCharCode(byte);\n  return btoa(binary);\n}\n\nfunction decodeBase64(value: string): Uint8Array {\n  const binary = atob(value);\n  return Uint8Array.from(binary, (character) => character.charCodeAt(0));\n}\n\nasync function bodyBytes(body: RequestInit['body']): Promise<Uint8Array | undefined> {\n  if (body === undefined || body === null) return undefined;\n  if (typeof body === 'string') return encoder.encode(body);\n  if (body instanceof URLSearchParams) return encoder.encode(body.toString());\n  if (body instanceof Blob) return new Uint8Array(await body.arrayBuffer());\n  if (body instanceof ArrayBuffer) return new Uint8Array(body);\n  if (ArrayBuffer.isView(body)) return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);\n  throw new Error('The sealed HTTP transport does not support this request body type.');\n}\n\nfunction requestTarget(input: string): string {\n  if (!input.startsWith('/')) throw new Error('A sealed HTTP request must use a root-relative URL.');\n  return input;\n}\n\nfunction isSealedHttpResponse(value: unknown): value is SealedHttpResponse {\n  if (typeof value !== 'object' || value === null) return false;\n  const candidate = value as Partial<SealedHttpResponse>;\n  return (\n    candidate.v === 1 &&\n    typeof candidate.status === 'number' &&\n    Array.isArray(candidate.headers) &&\n    candidate.headers.every(\n      (header) => Array.isArray(header) && header.length === 2 && header.every((part) => typeof part === 'string'),\n    ) &&\n    typeof candidate.body === 'string'\n  );\n}\nexport function createSealedTransport(): SealedTransport & {\n  /** Completes the handshake against the host key from the QR. */\n  connect: (hostPublicKey: string) => Promise<string | undefined>;\n  /** Drops the channel, so everything falls back to pass-through. */\n  reset: () => void;\n  /** Selects the same-origin endpoint that carries sealed HTTP exchanges. */\n  relayRequestsThrough: (path: string) => void;\n} {\n  let channel: SealedChannel | undefined;\n  let failure: string | undefined;\n  const outbound = createSerialQueue();\n  const inbound = createSerialQueue();\n  const exchange = createSerialQueue();\n  let relayPath: string | undefined;\n  const note = (reason: SealedFailure): undefined => {\n    // A decryption failure otherwise shows up as a blank page with no cause, so\n    // every one of them names itself.\n    failure = describeSealedFailure(reason);\n    return undefined;\n  };\n\n  const sealBytes = async (bytes: Uint8Array): Promise<string | undefined> => {\n    if (channel === undefined) return undefined;\n    const sealed = await channel.seal(bytes);\n    if (!sealed.ok) return note(sealed.failure);\n    return JSON.stringify(sealed.envelope);\n  };\n\n  const openBytes = async (text: string): Promise<Uint8Array | undefined> => {\n    if (channel === undefined) return undefined;\n    let envelope: unknown;\n    try {\n      envelope = JSON.parse(text);\n    } catch {\n      return note('malformed');\n    }\n    const opened = await channel.open(envelope);\n    if (!opened.ok) return note(opened.failure);\n    return opened.plaintext;\n  };\n\n  return {\n    active: () => channel !== undefined,\n    lastFailure: () => failure,\n\n    async connect(hostPublicKey) {\n      const connected = await connectSealedChannel(hostPublicKey);\n      if (connected === undefined) {\n        failure = 'This browser could not establish a sealed channel.';\n        return undefined;\n      }\n      channel = connected.channel;\n      failure = undefined;\n      return connected.clientPublicKey;\n    },\n\n    relayRequestsThrough(path) {\n      relayPath = path;\n    },\n\n    reset() {\n      channel = undefined;\n      failure = undefined;\n    },\n\n    async sealText(text) {\n      if (channel === undefined) return text;\n      return await outbound.run(async () => {\n        const sealed = await sealBytes(encoder.encode(text));\n        if (sealed === undefined) throw new Error(failure ?? 'The active sealed channel could not encrypt a message.');\n        return sealed;\n      });\n    },\n\n    async openText(text) {\n      if (channel === undefined) return text;\n      return await inbound.run(async () => {\n        const opened = await openBytes(text);\n        return opened === undefined ? undefined : decoder.decode(opened);\n      });\n    },\n\n    async sealBinary(bytes) {\n      if (channel === undefined) return bytes;\n      return await outbound.run(async () => {\n        const sealed = await sealBytes(bytes);\n        if (sealed === undefined) throw new Error(failure ?? 'The active sealed channel could not encrypt a message.');\n        return encoder.encode(sealed);\n      });\n    },\n\n    async openBinary(bytes) {\n      if (channel === undefined) return bytes;\n      return await inbound.run(async () => await openBytes(decoder.decode(bytes)));\n    },\n\n    async fetch(input, init) {\n      const gateway = relayPath;\n      if (channel === undefined || gateway === undefined) return await fetch(input, init);\n      return await exchange.run(async () => {\n        const bytes = await bodyBytes(init?.body);\n        const request: SealedHttpRequest = {\n          v: 1,\n          method: (init?.method ?? 'GET').toUpperCase(),\n          target: requestTarget(input),\n          headers: Array.from(new Headers(init?.headers).entries()),\n          ...(bytes === undefined ? {} : { body: encodeBase64(bytes) }),\n        };\n        const sealed = await sealBytes(encoder.encode(JSON.stringify(request)));\n        if (sealed === undefined) {\n          return new Response(JSON.stringify({ error: failure }), { status: 502 });\n        }\n        const relayResponse = await fetch(gateway, {\n          method: 'POST',\n          credentials: 'same-origin',\n          headers: { 'content-type': JSON_CONTENT_TYPE },\n          body: sealed,\n        });\n        const opened = await openBytes(await relayResponse.text());\n        if (opened === undefined) {\n          return new Response(JSON.stringify({ error: failure }), { status: 502 });\n        }\n        let decoded: unknown;\n        try {\n          decoded = JSON.parse(decoder.decode(opened));\n        } catch {\n          decoded = undefined;\n        }\n        if (!isSealedHttpResponse(decoded)) {\n          failure = 'The sealed HTTP response was malformed.';\n          return new Response(JSON.stringify({ error: failure }), { status: 502 });\n        }\n        const body = decodeBase64(decoded.body);\n        return new Response(decoded.status === 204 || decoded.status === 205 || decoded.status === 304 ? null : body, {\n          status: decoded.status,\n          headers: decoded.headers,\n        });\n      });\n    },\n  };\n}\n\n/**\n * The page's one sealed channel.\n *\n * A module singleton rather than an instance per caller, because the cockpit\n * and every plugin are bundled into the same page and all of them must share\n * one pair of nonce counters. Two transports over one handshake would each\n * start counting at zero and the receiver would reject the second as a replay.\n *\n * Inactive until a handshake completes, and inactive forever on the loopback\n * listener, so `sealedTransport.fetch` is a plain `fetch` there.\n */\nexport const sealedTransport = createSealedTransport();\n"],"mappings":"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"}

package/dist/adapters/sealedTransport.d.cts

@@ -0,0 +1,43 @@
+//#region src/adapters/sealedTransport.d.ts
+interface SealedTransport {
+  /** False on loopback and before the handshake completes, where everything passes through. */
+  active(): boolean;
+  sealText(text: string): Promise<string>;
+  /** Undefined when the message could not be opened; `lastFailure` says why. */
+  openText(text: string): Promise<string | undefined>;
+  sealBinary(bytes: Uint8Array): Promise<Uint8Array>;
+  openBinary(bytes: Uint8Array): Promise<Uint8Array | undefined>;
+  /** Drop-in for `fetch`, relaying the complete request through the sealed channel when configured. */
+  fetch(input: string, init?: RequestInit): Promise<Response>;
+  lastFailure(): string | undefined;
+}
+declare function createSealedTransport(): SealedTransport & {
+  /** Completes the handshake against the host key from the QR. */
+  connect: (hostPublicKey: string) => Promise<string | undefined>;
+  /** Drops the channel, so everything falls back to pass-through. */
+  reset: () => void;
+  /** Selects the same-origin endpoint that carries sealed HTTP exchanges. */
+  relayRequestsThrough: (path: string) => void;
+};
+/**
+ * The page's one sealed channel.
+ *
+ * A module singleton rather than an instance per caller, because the cockpit
+ * and every plugin are bundled into the same page and all of them must share
+ * one pair of nonce counters. Two transports over one handshake would each
+ * start counting at zero and the receiver would reject the second as a replay.
+ *
+ * Inactive until a handshake completes, and inactive forever on the loopback
+ * listener, so `sealedTransport.fetch` is a plain `fetch` there.
+ */
+declare const sealedTransport: SealedTransport & {
+  /** Completes the handshake against the host key from the QR. */
+  connect: (hostPublicKey: string) => Promise<string | undefined>;
+  /** Drops the channel, so everything falls back to pass-through. */
+  reset: () => void;
+  /** Selects the same-origin endpoint that carries sealed HTTP exchanges. */
+  relayRequestsThrough: (path: string) => void;
+};
+//#endregion
+export { SealedTransport, createSealedTransport, sealedTransport };
+//# sourceMappingURL=sealedTransport.d.cts.map

package/dist/adapters/sealedTransport.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sealedTransport.d.cts","names":[],"sources":["../../src/adapters/sealedTransport.ts"],"mappings":";UAqBiB;;EAEf;EACA,SAAS,eAAe;;EAExB,SAAS,eAAe;EACxB,WAAW,OAAO,aAAa,QAAQ;EACvC,WAAW,OAAO,aAAa,QAAQ;;EAEvC,MAAM,eAAe,OAAO,cAAc,QAAQ;EAClD;;iBA4Dc,yBAAyB;;EAEvC,UAAU,0BAA0B;;EAEpC;;EAEA,uBAAuB;;;;;;;;;;;;;cAmJZ,iBAAe;;EAvJjB,UAAC,0BAA0B;;EAE7B;;EAEe,uBAAC"}