wire-mesh-core 1.35.1 → 1.36.0

package/dist/domain/notice-board.cjs

@@ -0,0 +1,127 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_generated_protocol = require("../generated/protocol.cjs");
+const require_domain_data_sync = require("./data-sync.cjs");
+const require_domain_group_key = require("./group-key.cjs");
+const require_domain_room = require("./room.cjs");
+let cbor2 = require("cbor2");
+//#region src/domain/notice-board.ts
+/**
+* The application-ready noticeboard (spec/room.cddl's own noticeboard extension of core/room, wire-mesh#36): composes core/data's oplog replication (data-sync.ts), room-notice signing and verification (room.ts), and the room.rekey content-key machinery (group-key.ts, room-rekey.ts) into the one primitive an application actually wires -- post an encrypted notice to your own log, ingest a replicated peer entry, read back a room's notices verified and (where this side holds the epoch key) decrypted.
+*
+* Deliberately NOT included here, matching data-sync.ts's own "primitive vs. policy" split: when to send the returned data-have frame, which peers' logs to track, how to fan a catch-up request out -- all application policy. The board only guarantees what its pieces each already guarantee individually: own-log appends are monotonic, peer ingests are gap-rejecting, and nothing is ever surfaced unverified.
+*
+* readPeerNotices' honest read-confidentiality behaviour: a notice this side cannot decrypt (no key for its epoch -- a pre-join notice, or a post-kick epoch) still verifies and still appears in the read, with plaintext undefined. Authenticity and confidentiality are independent properties; the board never conflates them.
+*/
+/** The opaque byte length a caller-omitted noticeId gets: 16 random bytes, the same sizing token-id already uses. */
+const GENERATED_NOTICE_ID_BYTE_LENGTH = 16;
+/** Serialises a minted notice to the canonical CBOR bytes an oplog entry carries. */
+function noticeToEntryBytes(notice) {
+	return new Uint8Array((0, cbor2.encode)(notice, cbor2.cdeEncodeOptions));
+}
+function createNoticeBoard(options) {
+	const { identity, storage, clock, revocation, roomKeys } = options;
+	async function postEncryptedNotice(post) {
+		const keyEpoch = await roomKeys.currentEpoch(post.room);
+		if (keyEpoch === void 0) throw new Error(`no content key held for room ${post.room}: room.rekey this room before posting encrypted notices`);
+		const contentKey = await roomKeys.get(post.room, keyEpoch);
+		if (contentKey === void 0) throw new Error(`content key store is inconsistent: epoch ${String(keyEpoch)} is current for room ${post.room} but holds no key`);
+		const noticeId = post.noticeId ?? crypto.getRandomValues(new Uint8Array(GENERATED_NOTICE_ID_BYTE_LENGTH));
+		const ciphertext = await require_domain_group_key.encryptNoticeContent(contentKey, post.plaintext);
+		const notice = await require_domain_room.createRoomNotice({
+			identity,
+			clock,
+			room: post.room,
+			token: post.token,
+			noticeId,
+			contentType: require_domain_group_key.encryptedContentType(post.contentType),
+			content: ciphertext,
+			keyEpoch
+		});
+		const { haveFrame: dataHave } = await require_domain_data_sync.appendOwnEntry({
+			identity,
+			storage
+		}, noticeToEntryBytes(notice));
+		return {
+			dataHave,
+			notice,
+			keyEpoch
+		};
+	}
+	async function ingestPeerEntry(peer, entry) {
+		const fromSeq = await require_domain_data_sync.headSeqFor(storage, peer);
+		if (!(await require_domain_data_sync.handleDataEntries(storage, {
+			type: "data-entries",
+			peer,
+			"from-seq": fromSeq,
+			entries: [entry]
+		})).ok) throw new Error(`gap rejecting entry for peer log (head ${String(fromSeq)})`);
+	}
+	async function readLog(peer, room) {
+		const entries = await require_domain_data_sync.readEntries(storage, peer, 0);
+		const out = [];
+		for (const entry of entries) out.push(await readOne(entry, room));
+		return out;
+	}
+	async function readOne(entry, room) {
+		const notice = decodeNotice(entry);
+		if (notice === void 0) return {
+			verified: false,
+			reason: "malformed"
+		};
+		const verdict = await require_domain_room.verifyRoomNotice(notice, {
+			identity,
+			clock,
+			revocation,
+			expectedRoom: room
+		});
+		if (!verdict.ok) return {
+			verified: false,
+			reason: verdict.reason
+		};
+		const claims = verdict.claims;
+		if (!require_domain_group_key.isEncryptedContentType(claims["content-type"])) return {
+			verified: true,
+			contentType: claims["content-type"],
+			plaintext: claims.content,
+			claims
+		};
+		const keyEpoch = claims["key-epoch"];
+		if (keyEpoch === void 0) return {
+			verified: false,
+			reason: "key_epoch_mismatch"
+		};
+		const contentKey = await roomKeys.get(claims.room, keyEpoch);
+		const base = {
+			verified: true,
+			contentType: require_domain_group_key.plaintextContentType(claims["content-type"]),
+			claims
+		};
+		if (contentKey === void 0) return base;
+		try {
+			const plaintext = await require_domain_group_key.decryptNoticeContent(contentKey, claims.content);
+			return {
+				...base,
+				plaintext
+			};
+		} catch {
+			return base;
+		}
+	}
+	function decodeNotice(entry) {
+		try {
+			const decoded = (0, cbor2.decode)(entry, cbor2.cdeDecodeOptions);
+			const parsed = require_generated_protocol.roomNoticeSchema.safeParse(decoded);
+			return parsed.success ? parsed.data : void 0;
+		} catch {
+			return;
+		}
+	}
+	return {
+		postEncryptedNotice,
+		ingestPeerEntry,
+		readOwnNotices: async (room) => readLog(identity.deviceId, room),
+		readPeerNotices: async (peer, room) => readLog(peer, room)
+	};
+}
+//#endregion
+exports.createNoticeBoard = createNoticeBoard;

package/dist/domain/notice-board.d.cts

@@ -0,0 +1,60 @@
+import { D as DeviceId, Et as RoomNoticeClaims, T as DataHaveFrame, Tt as RoomNotice, p as CapabilityToken } from "../protocol-gbXtNeOc.cjs";
+import { KeyValueStorage } from "../ports/storage.cjs";
+import { t as IdentityPort } from "../identity-B4XBWkqg.cjs";
+import { t as Clock } from "../clock-DiSx-WKM.cjs";
+import { a as RevocationCheck } from "../tokens-C9Kwy0Gk.cjs";
+import { RoomNoticeVerdictReason } from "./room.cjs";
+//#region src/domain/notice-board.d.ts
+/**
+ * Where an application keeps the content keys its createRoomRekeyHandler unwraps, and where the owner's own side stores every epoch key it generated. Room-keyed and epoch-keyed, because a reader must locate exactly the epoch a notice names, never guess.
+ */
+export interface RoomKeyStore {
+  get: (room: string, epoch: number) => Promise<Uint8Array | undefined>;
+  set: (room: string, epoch: number, key: Uint8Array) => void;
+  /** The highest epoch held for a room -- what postEncryptedNotice stamps a new notice with. */
+  currentEpoch: (room: string) => Promise<number | undefined>;
+}
+/** One notice as read back from a log: always verified-or-not first, decrypted only when both the signature and the epoch key are held. */
+export interface NoticeBoardEntry {
+  /** Whether verifyRoomNotice passed every obligation. False means nothing else on this entry is populated except reason -- unverified content is never surfaced, not even as ciphertext. */
+  verified: boolean;
+  /** Why verification failed, when it did. */
+  reason?: RoomNoticeVerdictReason;
+  /** The notice's own TRUE (suffix-stripped) content-type, on a verified entry. */
+  contentType?: string;
+  /** The decrypted content, present iff verified AND this side holds the epoch key (or the notice was never encrypted). Undefined means "valid notice, can't read it" -- the confidentiality property, not an error. */
+  plaintext?: Uint8Array;
+  /** The fully verified claims, on a verified entry -- posted-at, poster, refs, everything a UI renders around the content itself. */
+  claims?: RoomNoticeClaims;
+}
+export interface CreateNoticeBoardOptions {
+  identity: IdentityPort;
+  storage: KeyValueStorage;
+  clock: Clock;
+  revocation: RevocationCheck;
+  roomKeys: RoomKeyStore;
+}
+export interface PostEncryptedNoticeOptions {
+  room: string;
+  /** The poster's own room:member token, embedded in full in the notice. */
+  token: CapabilityToken;
+  /** The notice's true content-type; the +aes256gcm suffix is applied here, never by the caller. */
+  contentType: string;
+  plaintext: Uint8Array;
+  /** Caller-supplied notice id, matching createRoomNotice's own convention; fresh random bytes when omitted. */
+  noticeId?: Uint8Array<ArrayBuffer>;
+}
+export interface PostedNotice {
+  /** The data-have frame announcing the new entry -- the application decides when and to whom to actually send it. */
+  dataHave: DataHaveFrame;
+  notice: RoomNotice;
+  /** The epoch the notice was encrypted under. */
+  keyEpoch: number;
+}
+export declare function createNoticeBoard(options: Readonly<CreateNoticeBoardOptions>): {
+  postEncryptedNotice: (post: Readonly<PostEncryptedNoticeOptions>) => Promise<PostedNotice>;
+  ingestPeerEntry: (peer: DeviceId, entry: Uint8Array<ArrayBuffer>) => Promise<void>;
+  readOwnNotices: (room: string) => Promise<NoticeBoardEntry[]>;
+  readPeerNotices: (peer: DeviceId, room: string) => Promise<NoticeBoardEntry[]>;
+};
+//#endregion

package/dist/domain/notice-board.d.mts

@@ -0,0 +1,60 @@
+import { D as DeviceId, Et as RoomNoticeClaims, T as DataHaveFrame, Tt as RoomNotice, p as CapabilityToken } from "../protocol-gbXtNeOc.mjs";
+import { KeyValueStorage } from "../ports/storage.mjs";
+import { t as IdentityPort } from "../identity-CIb9dGkJ.mjs";
+import { t as Clock } from "../clock-DiSx-WKM.mjs";
+import { a as RevocationCheck } from "../tokens-k172l0Iy.mjs";
+import { RoomNoticeVerdictReason } from "./room.mjs";
+//#region src/domain/notice-board.d.ts
+/**
+ * Where an application keeps the content keys its createRoomRekeyHandler unwraps, and where the owner's own side stores every epoch key it generated. Room-keyed and epoch-keyed, because a reader must locate exactly the epoch a notice names, never guess.
+ */
+export interface RoomKeyStore {
+  get: (room: string, epoch: number) => Promise<Uint8Array | undefined>;
+  set: (room: string, epoch: number, key: Uint8Array) => void;
+  /** The highest epoch held for a room -- what postEncryptedNotice stamps a new notice with. */
+  currentEpoch: (room: string) => Promise<number | undefined>;
+}
+/** One notice as read back from a log: always verified-or-not first, decrypted only when both the signature and the epoch key are held. */
+export interface NoticeBoardEntry {
+  /** Whether verifyRoomNotice passed every obligation. False means nothing else on this entry is populated except reason -- unverified content is never surfaced, not even as ciphertext. */
+  verified: boolean;
+  /** Why verification failed, when it did. */
+  reason?: RoomNoticeVerdictReason;
+  /** The notice's own TRUE (suffix-stripped) content-type, on a verified entry. */
+  contentType?: string;
+  /** The decrypted content, present iff verified AND this side holds the epoch key (or the notice was never encrypted). Undefined means "valid notice, can't read it" -- the confidentiality property, not an error. */
+  plaintext?: Uint8Array;
+  /** The fully verified claims, on a verified entry -- posted-at, poster, refs, everything a UI renders around the content itself. */
+  claims?: RoomNoticeClaims;
+}
+export interface CreateNoticeBoardOptions {
+  identity: IdentityPort;
+  storage: KeyValueStorage;
+  clock: Clock;
+  revocation: RevocationCheck;
+  roomKeys: RoomKeyStore;
+}
+export interface PostEncryptedNoticeOptions {
+  room: string;
+  /** The poster's own room:member token, embedded in full in the notice. */
+  token: CapabilityToken;
+  /** The notice's true content-type; the +aes256gcm suffix is applied here, never by the caller. */
+  contentType: string;
+  plaintext: Uint8Array;
+  /** Caller-supplied notice id, matching createRoomNotice's own convention; fresh random bytes when omitted. */
+  noticeId?: Uint8Array<ArrayBuffer>;
+}
+export interface PostedNotice {
+  /** The data-have frame announcing the new entry -- the application decides when and to whom to actually send it. */
+  dataHave: DataHaveFrame;
+  notice: RoomNotice;
+  /** The epoch the notice was encrypted under. */
+  keyEpoch: number;
+}
+export declare function createNoticeBoard(options: Readonly<CreateNoticeBoardOptions>): {
+  postEncryptedNotice: (post: Readonly<PostEncryptedNoticeOptions>) => Promise<PostedNotice>;
+  ingestPeerEntry: (peer: DeviceId, entry: Uint8Array<ArrayBuffer>) => Promise<void>;
+  readOwnNotices: (room: string) => Promise<NoticeBoardEntry[]>;
+  readPeerNotices: (peer: DeviceId, room: string) => Promise<NoticeBoardEntry[]>;
+};
+//#endregion

package/dist/domain/notice-board.mjs

@@ -0,0 +1,126 @@
+import { roomNoticeSchema } from "../generated/protocol.mjs";
+import { appendOwnEntry, handleDataEntries, headSeqFor, readEntries } from "./data-sync.mjs";
+import { decryptNoticeContent, encryptNoticeContent, encryptedContentType, isEncryptedContentType, plaintextContentType } from "./group-key.mjs";
+import { createRoomNotice, verifyRoomNotice } from "./room.mjs";
+import { cdeDecodeOptions, cdeEncodeOptions, decode, encode } from "cbor2";
+//#region src/domain/notice-board.ts
+/**
+* The application-ready noticeboard (spec/room.cddl's own noticeboard extension of core/room, wire-mesh#36): composes core/data's oplog replication (data-sync.ts), room-notice signing and verification (room.ts), and the room.rekey content-key machinery (group-key.ts, room-rekey.ts) into the one primitive an application actually wires -- post an encrypted notice to your own log, ingest a replicated peer entry, read back a room's notices verified and (where this side holds the epoch key) decrypted.
+*
+* Deliberately NOT included here, matching data-sync.ts's own "primitive vs. policy" split: when to send the returned data-have frame, which peers' logs to track, how to fan a catch-up request out -- all application policy. The board only guarantees what its pieces each already guarantee individually: own-log appends are monotonic, peer ingests are gap-rejecting, and nothing is ever surfaced unverified.
+*
+* readPeerNotices' honest read-confidentiality behaviour: a notice this side cannot decrypt (no key for its epoch -- a pre-join notice, or a post-kick epoch) still verifies and still appears in the read, with plaintext undefined. Authenticity and confidentiality are independent properties; the board never conflates them.
+*/
+/** The opaque byte length a caller-omitted noticeId gets: 16 random bytes, the same sizing token-id already uses. */
+const GENERATED_NOTICE_ID_BYTE_LENGTH = 16;
+/** Serialises a minted notice to the canonical CBOR bytes an oplog entry carries. */
+function noticeToEntryBytes(notice) {
+	return new Uint8Array(encode(notice, cdeEncodeOptions));
+}
+function createNoticeBoard(options) {
+	const { identity, storage, clock, revocation, roomKeys } = options;
+	async function postEncryptedNotice(post) {
+		const keyEpoch = await roomKeys.currentEpoch(post.room);
+		if (keyEpoch === void 0) throw new Error(`no content key held for room ${post.room}: room.rekey this room before posting encrypted notices`);
+		const contentKey = await roomKeys.get(post.room, keyEpoch);
+		if (contentKey === void 0) throw new Error(`content key store is inconsistent: epoch ${String(keyEpoch)} is current for room ${post.room} but holds no key`);
+		const noticeId = post.noticeId ?? crypto.getRandomValues(new Uint8Array(GENERATED_NOTICE_ID_BYTE_LENGTH));
+		const ciphertext = await encryptNoticeContent(contentKey, post.plaintext);
+		const notice = await createRoomNotice({
+			identity,
+			clock,
+			room: post.room,
+			token: post.token,
+			noticeId,
+			contentType: encryptedContentType(post.contentType),
+			content: ciphertext,
+			keyEpoch
+		});
+		const { haveFrame: dataHave } = await appendOwnEntry({
+			identity,
+			storage
+		}, noticeToEntryBytes(notice));
+		return {
+			dataHave,
+			notice,
+			keyEpoch
+		};
+	}
+	async function ingestPeerEntry(peer, entry) {
+		const fromSeq = await headSeqFor(storage, peer);
+		if (!(await handleDataEntries(storage, {
+			type: "data-entries",
+			peer,
+			"from-seq": fromSeq,
+			entries: [entry]
+		})).ok) throw new Error(`gap rejecting entry for peer log (head ${String(fromSeq)})`);
+	}
+	async function readLog(peer, room) {
+		const entries = await readEntries(storage, peer, 0);
+		const out = [];
+		for (const entry of entries) out.push(await readOne(entry, room));
+		return out;
+	}
+	async function readOne(entry, room) {
+		const notice = decodeNotice(entry);
+		if (notice === void 0) return {
+			verified: false,
+			reason: "malformed"
+		};
+		const verdict = await verifyRoomNotice(notice, {
+			identity,
+			clock,
+			revocation,
+			expectedRoom: room
+		});
+		if (!verdict.ok) return {
+			verified: false,
+			reason: verdict.reason
+		};
+		const claims = verdict.claims;
+		if (!isEncryptedContentType(claims["content-type"])) return {
+			verified: true,
+			contentType: claims["content-type"],
+			plaintext: claims.content,
+			claims
+		};
+		const keyEpoch = claims["key-epoch"];
+		if (keyEpoch === void 0) return {
+			verified: false,
+			reason: "key_epoch_mismatch"
+		};
+		const contentKey = await roomKeys.get(claims.room, keyEpoch);
+		const base = {
+			verified: true,
+			contentType: plaintextContentType(claims["content-type"]),
+			claims
+		};
+		if (contentKey === void 0) return base;
+		try {
+			const plaintext = await decryptNoticeContent(contentKey, claims.content);
+			return {
+				...base,
+				plaintext
+			};
+		} catch {
+			return base;
+		}
+	}
+	function decodeNotice(entry) {
+		try {
+			const decoded = decode(entry, cdeDecodeOptions);
+			const parsed = roomNoticeSchema.safeParse(decoded);
+			return parsed.success ? parsed.data : void 0;
+		} catch {
+			return;
+		}
+	}
+	return {
+		postEncryptedNotice,
+		ingestPeerEntry,
+		readOwnNotices: async (room) => readLog(identity.deviceId, room),
+		readPeerNotices: async (peer, room) => readLog(peer, room)
+	};
+}
+//#endregion
+export { createNoticeBoard };

package/dist/domain/room-token-verification.d.cts

@@ -1,26 +1,2 @@
-import { B as IdentityKey, D as DeviceId, It as TokenClaims, p as CapabilityToken } from "../protocol-gbXtNeOc.cjs";
-import { l as TokenVerdictReason, u as VerifyCapabilityTokenOptions } from "../tokens-C9Kwy0Gk.cjs";
-//#region src/domain/room-token-verification.d.ts
-/** The one capability every core/room verb (room.send/read/leave/members) is gated by, per spec/room.cddl -- room.join/room.invite are deliberately ungated instead and need no token check at all. */
-export declare const ROOM_MEMBER_CAPABILITY = "room:member";
-export type RoomTokenVerdictReason = TokenVerdictReason | "wrong_scope_kind" | "wrong_scope_path" | "wrong_chain_root";
-export type RoomTokenVerdict = {
-  ok: true;
-  claims: TokenClaims;
-  /** The chain's own certified root issuer-key -- for a named room, this is exactly the room's rightful owner (obligation 1 just confirmed the chain terminates there), and for a DM it's the verifying identity's own key. Lets a caller (e.g. room.rekey's own handler) derive an ECDH shared secret against the room's real owner with no separate live-sender identity check needed. */
-  rootIssuerKey: IdentityKey;
-} | {
-  ok: false;
-  reason: RoomTokenVerdictReason;
-};
-export interface VerifyRoomTokenOptions extends Omit<VerifyCapabilityTokenOptions, "expectedBearer"> {
-  /** The peer identity actually authenticated on the arriving connection (obligation 2) -- never a relay-asserted or gossip-derived value. Mandatory here: every room verb requires a bearer, unlike verifyCapabilityToken's own optional field for callers presenting a token to authorise themselves rather than a specific counterparty. */
-  expectedBearer: DeviceId;
-  /** The room path this request claims to act on (obligation 3) -- must equal the token's own scope.path, and its own shape determines the chain root obligation 1 requires. */
-  roomPath: string;
-}
-/**
- * Verifies a `room:member` capability token against all six of core/room's verifier obligations. Delegates obligations 2/4/5 to verifyCapabilityToken directly; adds obligation 3 (scope.kind/scope.path must match the room being acted on) and obligation 1 (the chain's root must be the room's own owner for a named room, or the verifying identity itself for a DM -- never either named participant directly, since a DM token minted by anyone other than the verifier would let a sender self-issue authority to message a stranger unsolicited).
- */
-export declare function verifyRoomToken(token: CapabilityToken, options: Readonly<VerifyRoomTokenOptions>): Promise<RoomTokenVerdict>;
-//#endregion
+import { a as verifyRoomToken, i as VerifyRoomTokenOptions, n as RoomTokenVerdict, r as RoomTokenVerdictReason, t as ROOM_MEMBER_CAPABILITY } from "../room-token-verification-BY9AwZQ-.cjs";
+export { ROOM_MEMBER_CAPABILITY, RoomTokenVerdict, RoomTokenVerdictReason, VerifyRoomTokenOptions, verifyRoomToken };

package/dist/domain/room-token-verification.d.mts

@@ -1,26 +1,2 @@
-import { B as IdentityKey, D as DeviceId, It as TokenClaims, p as CapabilityToken } from "../protocol-gbXtNeOc.mjs";
-import { l as TokenVerdictReason, u as VerifyCapabilityTokenOptions } from "../tokens-k172l0Iy.mjs";
-//#region src/domain/room-token-verification.d.ts
-/** The one capability every core/room verb (room.send/read/leave/members) is gated by, per spec/room.cddl -- room.join/room.invite are deliberately ungated instead and need no token check at all. */
-export declare const ROOM_MEMBER_CAPABILITY = "room:member";
-export type RoomTokenVerdictReason = TokenVerdictReason | "wrong_scope_kind" | "wrong_scope_path" | "wrong_chain_root";
-export type RoomTokenVerdict = {
-  ok: true;
-  claims: TokenClaims;
-  /** The chain's own certified root issuer-key -- for a named room, this is exactly the room's rightful owner (obligation 1 just confirmed the chain terminates there), and for a DM it's the verifying identity's own key. Lets a caller (e.g. room.rekey's own handler) derive an ECDH shared secret against the room's real owner with no separate live-sender identity check needed. */
-  rootIssuerKey: IdentityKey;
-} | {
-  ok: false;
-  reason: RoomTokenVerdictReason;
-};
-export interface VerifyRoomTokenOptions extends Omit<VerifyCapabilityTokenOptions, "expectedBearer"> {
-  /** The peer identity actually authenticated on the arriving connection (obligation 2) -- never a relay-asserted or gossip-derived value. Mandatory here: every room verb requires a bearer, unlike verifyCapabilityToken's own optional field for callers presenting a token to authorise themselves rather than a specific counterparty. */
-  expectedBearer: DeviceId;
-  /** The room path this request claims to act on (obligation 3) -- must equal the token's own scope.path, and its own shape determines the chain root obligation 1 requires. */
-  roomPath: string;
-}
-/**
- * Verifies a `room:member` capability token against all six of core/room's verifier obligations. Delegates obligations 2/4/5 to verifyCapabilityToken directly; adds obligation 3 (scope.kind/scope.path must match the room being acted on) and obligation 1 (the chain's root must be the room's own owner for a named room, or the verifying identity itself for a DM -- never either named participant directly, since a DM token minted by anyone other than the verifier would let a sender self-issue authority to message a stranger unsolicited).
- */
-export declare function verifyRoomToken(token: CapabilityToken, options: Readonly<VerifyRoomTokenOptions>): Promise<RoomTokenVerdict>;
-//#endregion
+import { a as verifyRoomToken, i as VerifyRoomTokenOptions, n as RoomTokenVerdict, r as RoomTokenVerdictReason, t as ROOM_MEMBER_CAPABILITY } from "../room-token-verification-CYKEP_h6.mjs";
+export { ROOM_MEMBER_CAPABILITY, RoomTokenVerdict, RoomTokenVerdictReason, VerifyRoomTokenOptions, verifyRoomToken };

package/dist/domain/room.d.cts

@@ -2,7 +2,7 @@ import { Dt as RoomPath, Et as RoomNoticeClaims, Tt as RoomNotice, p as Capabili
 import { t as IdentityPort } from "../identity-B4XBWkqg.cjs";
 import { t as Clock } from "../clock-DiSx-WKM.cjs";
 import { a as RevocationCheck } from "../tokens-C9Kwy0Gk.cjs";
-import { RoomTokenVerdictReason } from "./room-token-verification.cjs";
+import { r as RoomTokenVerdictReason } from "../room-token-verification-BY9AwZQ-.cjs";
 //#region src/domain/room.d.ts
 export type RoomNoticeVerdictReason = "malformed" | "wrong_room" | "bad_signature" | "wrong_poster" | "content_expired" | "key_epoch_mismatch" | RoomTokenVerdictReason;
 export type RoomNoticeVerdict = {

package/dist/domain/room.d.mts

@@ -2,7 +2,7 @@ import { Dt as RoomPath, Et as RoomNoticeClaims, Tt as RoomNotice, p as Capabili
 import { t as IdentityPort } from "../identity-CIb9dGkJ.mjs";
 import { t as Clock } from "../clock-DiSx-WKM.mjs";
 import { a as RevocationCheck } from "../tokens-k172l0Iy.mjs";
-import { RoomTokenVerdictReason } from "./room-token-verification.mjs";
+import { r as RoomTokenVerdictReason } from "../room-token-verification-CYKEP_h6.mjs";
 //#region src/domain/room.d.ts
 export type RoomNoticeVerdictReason = "malformed" | "wrong_room" | "bad_signature" | "wrong_poster" | "content_expired" | "key_epoch_mismatch" | RoomTokenVerdictReason;
 export type RoomNoticeVerdict = {

package/dist/room-token-verification-BY9AwZQ-.d.cts

@@ -0,0 +1,27 @@
+import { B as IdentityKey, D as DeviceId, It as TokenClaims, p as CapabilityToken } from "./protocol-gbXtNeOc.cjs";
+import { l as TokenVerdictReason, u as VerifyCapabilityTokenOptions } from "./tokens-C9Kwy0Gk.cjs";
+//#region src/domain/room-token-verification.d.ts
+/** The one capability every core/room verb (room.send/read/leave/members) is gated by, per spec/room.cddl -- room.join/room.invite are deliberately ungated instead and need no token check at all. */
+declare const ROOM_MEMBER_CAPABILITY = "room:member";
+type RoomTokenVerdictReason = TokenVerdictReason | "wrong_scope_kind" | "wrong_scope_path" | "wrong_chain_root";
+type RoomTokenVerdict = {
+  ok: true;
+  claims: TokenClaims;
+  /** The chain's own certified root issuer-key -- for a named room, this is exactly the room's rightful owner (obligation 1 just confirmed the chain terminates there), and for a DM it's the verifying identity's own key. Lets a caller (e.g. room.rekey's own handler) derive an ECDH shared secret against the room's real owner with no separate live-sender identity check needed. */
+  rootIssuerKey: IdentityKey;
+} | {
+  ok: false;
+  reason: RoomTokenVerdictReason;
+};
+interface VerifyRoomTokenOptions extends Omit<VerifyCapabilityTokenOptions, "expectedBearer"> {
+  /** The peer identity actually authenticated on the arriving connection (obligation 2) -- never a relay-asserted or gossip-derived value. Mandatory here: every room verb requires a bearer, unlike verifyCapabilityToken's own optional field for callers presenting a token to authorise themselves rather than a specific counterparty. */
+  expectedBearer: DeviceId;
+  /** The room path this request claims to act on (obligation 3) -- must equal the token's own scope.path, and its own shape determines the chain root obligation 1 requires. */
+  roomPath: string;
+}
+/**
+ * Verifies a `room:member` capability token against all six of core/room's verifier obligations. Delegates obligations 2/4/5 to verifyCapabilityToken directly; adds obligation 3 (scope.kind/scope.path must match the room being acted on) and obligation 1 (the chain's root must be the room's own owner for a named room, or the verifying identity itself for a DM -- never either named participant directly, since a DM token minted by anyone other than the verifier would let a sender self-issue authority to message a stranger unsolicited).
+ */
+declare function verifyRoomToken(token: CapabilityToken, options: Readonly<VerifyRoomTokenOptions>): Promise<RoomTokenVerdict>;
+//#endregion
+export { verifyRoomToken as a, VerifyRoomTokenOptions as i, RoomTokenVerdict as n, RoomTokenVerdictReason as r, ROOM_MEMBER_CAPABILITY as t };

package/dist/room-token-verification-CYKEP_h6.d.mts

@@ -0,0 +1,27 @@
+import { B as IdentityKey, D as DeviceId, It as TokenClaims, p as CapabilityToken } from "./protocol-gbXtNeOc.mjs";
+import { l as TokenVerdictReason, u as VerifyCapabilityTokenOptions } from "./tokens-k172l0Iy.mjs";
+//#region src/domain/room-token-verification.d.ts
+/** The one capability every core/room verb (room.send/read/leave/members) is gated by, per spec/room.cddl -- room.join/room.invite are deliberately ungated instead and need no token check at all. */
+declare const ROOM_MEMBER_CAPABILITY = "room:member";
+type RoomTokenVerdictReason = TokenVerdictReason | "wrong_scope_kind" | "wrong_scope_path" | "wrong_chain_root";
+type RoomTokenVerdict = {
+  ok: true;
+  claims: TokenClaims;
+  /** The chain's own certified root issuer-key -- for a named room, this is exactly the room's rightful owner (obligation 1 just confirmed the chain terminates there), and for a DM it's the verifying identity's own key. Lets a caller (e.g. room.rekey's own handler) derive an ECDH shared secret against the room's real owner with no separate live-sender identity check needed. */
+  rootIssuerKey: IdentityKey;
+} | {
+  ok: false;
+  reason: RoomTokenVerdictReason;
+};
+interface VerifyRoomTokenOptions extends Omit<VerifyCapabilityTokenOptions, "expectedBearer"> {
+  /** The peer identity actually authenticated on the arriving connection (obligation 2) -- never a relay-asserted or gossip-derived value. Mandatory here: every room verb requires a bearer, unlike verifyCapabilityToken's own optional field for callers presenting a token to authorise themselves rather than a specific counterparty. */
+  expectedBearer: DeviceId;
+  /** The room path this request claims to act on (obligation 3) -- must equal the token's own scope.path, and its own shape determines the chain root obligation 1 requires. */
+  roomPath: string;
+}
+/**
+ * Verifies a `room:member` capability token against all six of core/room's verifier obligations. Delegates obligations 2/4/5 to verifyCapabilityToken directly; adds obligation 3 (scope.kind/scope.path must match the room being acted on) and obligation 1 (the chain's root must be the room's own owner for a named room, or the verifying identity itself for a DM -- never either named participant directly, since a DM token minted by anyone other than the verifier would let a sender self-issue authority to message a stranger unsolicited).
+ */
+declare function verifyRoomToken(token: CapabilityToken, options: Readonly<VerifyRoomTokenOptions>): Promise<RoomTokenVerdict>;
+//#endregion
+export { verifyRoomToken as a, VerifyRoomTokenOptions as i, RoomTokenVerdict as n, RoomTokenVerdictReason as r, ROOM_MEMBER_CAPABILITY as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wire-mesh-core",
-  "version": "1.35.1",
+  "version": "1.36.0",
   "type": "module",
   "packageManager": "pnpm@12.4.1+sha512.2e81e399d73fe8390dab25e06aa788ab7a5908248d2f5a370f82b481147a6a7a367bf8048f9a6fdb6460f21a66f0542dedb8b94ca2c8723596741920b1656d4c",
   "repository": {
@@ -126,6 +126,10 @@
       "import": "./dist/domain/mesh-session.mjs",
       "require": "./dist/domain/mesh-session.cjs"
     },
+    "./domain/notice-board": {
+      "import": "./dist/domain/notice-board.mjs",
+      "require": "./dist/domain/notice-board.cjs"
+    },
     "./domain/relay-hub": {
       "import": "./dist/domain/relay-hub.mjs",
       "require": "./dist/domain/relay-hub.cjs"