wire-mesh-core 1.15.0 → 1.16.0

package/dist/adapters/frame-codec.d.cts

@@ -1,4 +1,4 @@
-import { E as Frame } from "../protocol-MnxTzpRP.cjs";
+import { D as Frame } from "../protocol-Dhswk7YD.cjs";
 //#region src/adapters/frame-codec.d.ts
 export declare function messageFromFrame(frame: Frame): Uint8Array<ArrayBuffer>;
 /** A frame that fails schema validation, caught separately from a decode failure so it can be dropped without disconnecting. */

package/dist/adapters/frame-codec.d.mts

@@ -1,4 +1,4 @@
-import { E as Frame } from "../protocol-MnxTzpRP.mjs";
+import { D as Frame } from "../protocol-Dhswk7YD.mjs";
 //#region src/adapters/frame-codec.d.ts
 export declare function messageFromFrame(frame: Frame): Uint8Array<ArrayBuffer>;
 /** A frame that fails schema validation, caught separately from a decode failure so it can be dropped without disconnecting. */

package/dist/adapters/node-identity.d.cts

@@ -1,5 +1,5 @@
-import { N as IdentityKey, b as DeviceId } from "../protocol-MnxTzpRP.cjs";
-import { t as IdentityPort } from "../identity-DkEe1465.cjs";
+import { P as IdentityKey, x as DeviceId } from "../protocol-Dhswk7YD.cjs";
+import { t as IdentityPort } from "../identity-BldV8xFj.cjs";
 import { webcrypto } from "node:crypto";
 //#region src/adapters/node-identity.d.ts
 export declare function deriveDeviceId(publicKey: Uint8Array): Promise<DeviceId>;

package/dist/adapters/node-identity.d.mts

@@ -1,5 +1,5 @@
-import { N as IdentityKey, b as DeviceId } from "../protocol-MnxTzpRP.mjs";
-import { t as IdentityPort } from "../identity-D8iJZRZZ.mjs";
+import { P as IdentityKey, x as DeviceId } from "../protocol-Dhswk7YD.mjs";
+import { t as IdentityPort } from "../identity-B1hBV3YA.mjs";
 import { webcrypto } from "node:crypto";
 //#region src/adapters/node-identity.d.ts
 export declare function deriveDeviceId(publicKey: Uint8Array): Promise<DeviceId>;

package/dist/adapters/tcp-transport.d.cts

@@ -1,4 +1,4 @@
-import { r as Transport } from "../transport-Da7GP9ya.cjs";
+import { r as Transport } from "../transport-hEUxrdhT.cjs";
 //#region src/adapters/tcp-transport.d.ts
 /** A Node net.Socket-based Transport: length-prefixed, CBOR-encoded frames over plain TCP -- matching Cascade's own transport shape, since interop with Cascade nodes is wire-mesh's stated goal. Framing (not TLS) is this adapter's own concern; a TLS-terminated variant is a separate adapter behind the same Transport contract. */
 export declare function createTcpTransport(): Transport;

package/dist/adapters/tcp-transport.d.mts

@@ -1,4 +1,4 @@
-import { r as Transport } from "../transport-ESMXRz3s.mjs";
+import { r as Transport } from "../transport-BNNdUBq-.mjs";
 //#region src/adapters/tcp-transport.d.ts
 /** A Node net.Socket-based Transport: length-prefixed, CBOR-encoded frames over plain TCP -- matching Cascade's own transport shape, since interop with Cascade nodes is wire-mesh's stated goal. Framing (not TLS) is this adapter's own concern; a TLS-terminated variant is a separate adapter behind the same Transport contract. */
 export declare function createTcpTransport(): Transport;

package/dist/adapters/tls-transport.d.cts

@@ -1,4 +1,4 @@
-import { r as Transport } from "../transport-Da7GP9ya.cjs";
+import { r as Transport } from "../transport-hEUxrdhT.cjs";
 //#region src/adapters/tls-transport.d.ts
 export interface TlsIdentity {
   certificatePem: string;

package/dist/adapters/tls-transport.d.mts

@@ -1,4 +1,4 @@
-import { r as Transport } from "../transport-ESMXRz3s.mjs";
+import { r as Transport } from "../transport-BNNdUBq-.mjs";
 //#region src/adapters/tls-transport.d.ts
 export interface TlsIdentity {
   certificatePem: string;

package/dist/domain/capability-grant.cjs

@@ -0,0 +1,90 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_generated_protocol = require("../generated/protocol.cjs");
+const require_domain_tokens = require("./tokens.cjs");
+//#region src/domain/capability-grant.ts
+/**
+* The generic, capability-agnostic capability-grant primitive (wire-mesh#117, spec/management.cddl) -- the unsolicited push counterpart to capability-request.ts's own ask/response primitive. Where capability-request lifts core/room's room.join shape (a pull: the requester asks, the owner mints and returns a grant on the same response) out of that one domain, capability-grant lifts room.invite's own shape (a push: the owner mints unprompted and delivers the grant in the request itself, since there is no approval round-trip to carry it back) the same way. core/room's own room-client.ts is the reference consumer: it builds sendRoomInvite as a thin wrapper over sendCapabilityGrant below, and wires createRoomRouter's dispatch onto createCapabilityGrantHandler for the receiving side.
+*
+* Two responsibilities, split the same way capability-request.ts already splits them: sendCapabilityGrant is the pushing side (a thin wrapper over MeshSession.sendManageRequest), and createCapabilityGrantHandler is the receiving side (validates the pushed token against all four of management.cddl's own capability-grant obligations, then hands the verified grant to the domain). Unlike capability-request's handler, there is no decide()/timeout mechanism here: management.cddl deliberately specifies no protocol-level approval round trip for this primitive (a receiver's manage-response reports validation success or failure only, never a human decision), so onGrant is a plain notification callback, not an event carrying its own responder.
+*/
+/**
+* Builds a capability-grant command per management.cddl. The outer `manage-command.verb` is the capability string itself, the identical convention capability-request.ts's own buildCapabilityRequestCommand already establishes -- a receiver's per-capability handler is how it knows which grant this push is even for. `params.verb` is the fixed "capability.grant" marker. No scope or invitee field: manage-request-frame's own top-level scope already carries the former, and the request's own destination already carries the latter -- naming either a second time inside params could only ever disagree with the fact it duplicates.
+*/
+function buildCapabilityGrantCommand(capability, grantedToken) {
+	return {
+		verb: capability,
+		params: {
+			verb: "capability.grant",
+			"granted-token": grantedToken
+		}
+	};
+}
+/**
+* Pushes an already-minted grantedToken to whichever peer this request is addressed to -- the caller mints grantedToken itself beforehand (there is no minting step here, unlike capability-request's own accept path, since this primitive carries a token the sender already decided to hand over unprompted). Resolves with the raw manage-response outcome: `{result:"ok"}` on successful validation, an ordinary manage-error otherwise (per management.cddl's own capability-grant obligations, this is a validation-failure code only, never a human "no" -- an application wanting a human-decision gate applies it on the RECEIVING side's own onGrant callback instead, exactly as core/room's own room.invite→room_invite delivery event already does today in agent-comms).
+*
+* scope and targetDevice forward directly to MeshSession.sendManageRequest's own identically-named parameters (the request's own top-level scope obligation 4 checks the token against, and relay routing respectively).
+*/
+async function sendCapabilityGrant(session, capability, grantedToken, scope, targetDevice) {
+	return session.sendManageRequest(buildCapabilityGrantCommand(capability, grantedToken), scope, targetDevice);
+}
+/**
+* Builds a reusable handler for one capability's incoming capability-grants. The returned function checks, in order: the outer verb names this handler's own capability (otherwise `{result:"error", code:"malformed"}`, matching capability-request.ts's identical check); the params payload parses against capability-grant's own CDDL shape (otherwise "malformed"); the embedded token independently passes every ordinary verifyCapabilityToken obligation with `expectedBearer` set to this receiver's OWN identity -- obligations 1 and 3 together, since an unsolicited push must name its actual recipient as bearer and must otherwise be exactly as valid as any other token (a verification failure responds with verifyCapabilityToken's own specific TokenVerdictReason as the error code, e.g. "expired"/"revoked"/"bad_signature", rather than a single generic code, mirroring how capability-request.ts already distinguishes "expired" from "malformed"); the token's own capability claim equals this handler's capability (obligation 2, otherwise "capability_mismatch"); and the token's own scope equals or roots the enclosing request's own top-level scope (obligation 4, via tokens.ts's own scopeNarrows -- otherwise "scope_mismatch"). Only once every obligation passes does it respond `{result:"ok"}` and invoke onGrant -- there is no decide()/timeout mechanism the way createCapabilityRequestHandler has one, since management.cddl specifies no protocol-level approval round trip for this primitive at all.
+*/
+function createCapabilityGrantHandler(options) {
+	return async function handleCapabilityGrant(incoming) {
+		if (incoming.command.verb !== options.capability) {
+			await incoming.respond({
+				result: "error",
+				code: "malformed"
+			});
+			return;
+		}
+		const parsed = require_generated_protocol.capabilityGrantSchema.safeParse(incoming.command.params);
+		if (!parsed.success) {
+			await incoming.respond({
+				result: "error",
+				code: "malformed"
+			});
+			return;
+		}
+		const grantedToken = parsed.data["granted-token"];
+		const verdict = await require_domain_tokens.verifyCapabilityToken(grantedToken, {
+			identity: options.identity,
+			clock: options.clock,
+			revocation: options.revocation,
+			expectedBearer: options.identity.deviceId
+		});
+		if (!verdict.ok) {
+			await incoming.respond({
+				result: "error",
+				code: verdict.reason
+			});
+			return;
+		}
+		if (verdict.claims.capability !== options.capability) {
+			await incoming.respond({
+				result: "error",
+				code: "capability_mismatch"
+			});
+			return;
+		}
+		if (!require_domain_tokens.scopeNarrows(verdict.claims.scope, incoming.scope)) {
+			await incoming.respond({
+				result: "error",
+				code: "scope_mismatch"
+			});
+			return;
+		}
+		await incoming.respond({ result: "ok" });
+		options.onGrant({
+			capability: options.capability,
+			grantedToken,
+			scope: incoming.scope,
+			granterDevice: options.granterDevice
+		});
+	};
+}
+//#endregion
+exports.buildCapabilityGrantCommand = buildCapabilityGrantCommand;
+exports.createCapabilityGrantHandler = createCapabilityGrantHandler;
+exports.sendCapabilityGrant = sendCapabilityGrant;

package/dist/domain/capability-grant.d.cts

@@ -0,0 +1,44 @@
+import { F as ManageCommand, o as CapabilityScope, s as CapabilityToken, x as DeviceId } from "../protocol-Dhswk7YD.cjs";
+import { t as IdentityPort } from "../identity-BldV8xFj.cjs";
+import { t as Clock } from "../clock-DiSx-WKM.cjs";
+import { IncomingManageRequest, ManageOutcome, MeshSession } from "./mesh-session.cjs";
+import { RevocationCheck } from "./tokens.cjs";
+//#region src/domain/capability-grant.d.ts
+/**
+ * Builds a capability-grant command per management.cddl. The outer `manage-command.verb` is the capability string itself, the identical convention capability-request.ts's own buildCapabilityRequestCommand already establishes -- a receiver's per-capability handler is how it knows which grant this push is even for. `params.verb` is the fixed "capability.grant" marker. No scope or invitee field: manage-request-frame's own top-level scope already carries the former, and the request's own destination already carries the latter -- naming either a second time inside params could only ever disagree with the fact it duplicates.
+ */
+export declare function buildCapabilityGrantCommand(capability: string, grantedToken: CapabilityToken): ManageCommand;
+/**
+ * Pushes an already-minted grantedToken to whichever peer this request is addressed to -- the caller mints grantedToken itself beforehand (there is no minting step here, unlike capability-request's own accept path, since this primitive carries a token the sender already decided to hand over unprompted). Resolves with the raw manage-response outcome: `{result:"ok"}` on successful validation, an ordinary manage-error otherwise (per management.cddl's own capability-grant obligations, this is a validation-failure code only, never a human "no" -- an application wanting a human-decision gate applies it on the RECEIVING side's own onGrant callback instead, exactly as core/room's own room.invite→room_invite delivery event already does today in agent-comms).
+ *
+ * scope and targetDevice forward directly to MeshSession.sendManageRequest's own identically-named parameters (the request's own top-level scope obligation 4 checks the token against, and relay routing respectively).
+ */
+export declare function sendCapabilityGrant(session: Readonly<MeshSession>, capability: string, grantedToken: CapabilityToken, scope: Readonly<CapabilityScope>, targetDevice?: DeviceId): Promise<ManageOutcome>;
+/** One incoming, fully-verified capability-grant, surfaced for the domain to react to (store the token, notify a human, etc.) -- there is no decide() here because management.cddl specifies no protocol-level approval round trip for this primitive; by the time onGrant fires, the wire response has already been sent. */
+export interface CapabilityGrantEvent {
+  /** The capability granted -- equals both the outer manage-command.verb and the verified token's own capability claim (obligation 2 already enforced this before onGrant fires). */
+  capability: string;
+  /** The pushed token, already confirmed to independently pass every ordinary verifyCapabilityToken obligation, name this receiver as its own bearer, and scope-match the enclosing request (obligations 1, 2, 3, and 4 respectively). Ready to use exactly as capability-request.ts's own CapabilityGrantOk["granted-token"] is on the pull side. */
+  grantedToken: CapabilityToken;
+  /** The scope this grant's own manage-request-frame carried -- e.g. core/room's `{kind:"room", path: roomPath}` -- passed through unchanged so the domain can inspect it (a room handler reads `.path` back out) without this module needing to know its shape. */
+  scope: Readonly<CapabilityScope>;
+  /** The peer device-id authenticated on the connection this grant arrived on -- the granter, surfaced so the domain can attribute the push (e.g. core/room's own room_invite event names the inviter). Never itself checked against the token's bearer (obligation 1 checks the RECIPIENT's own identity instead -- an unsolicited push names its own recipient by where it was sent, not by who sent it). */
+  granterDevice: DeviceId;
+}
+export interface CreateCapabilityGrantHandlerOptions {
+  /** The capability this handler accepts pushed grants for. Checked against the incoming command's own outer verb (a mismatch is refused as malformed, mirroring capability-request.ts's identical capability check) and against the verified token's own capability claim (obligation 2); a caller wanting to accept grants for several distinct capabilities over one session constructs one handler per capability, the same way core/room constructs one handler for `room:member` and nothing else. */
+  capability: string;
+  /** This receiver's own identity -- both the verification primitives every pushed token is checked with, and (via `.deviceId`) the value obligation 1 requires the token's own bearer to equal. There is no separate bearerDevice option the way CreateCapabilityRequestHandlerOptions has one: capability-request's handler mints a NEW token for whichever peer asked, so it needs that peer's device-id as an input; capability-grant's handler verifies an ALREADY-minted token against this side's own identity, which identity.deviceId already provides. */
+  identity: IdentityPort;
+  clock: Clock;
+  revocation: RevocationCheck;
+  /** The peer device-id authenticated on this session's own connection -- the granter, surfaced on every CapabilityGrantEvent so the domain can attribute the push. Never used for verification itself (see CapabilityGrantEvent.granterDevice's own doc comment on why obligation 1 checks the recipient's identity instead). */
+  granterDevice: DeviceId;
+  /** Called once per incoming, fully-verified capability-grant. Fires after the wire response has already been sent (see createCapabilityGrantHandler's own doc comment) -- this is a notification, not a decision point. */
+  onGrant: (event: Readonly<CapabilityGrantEvent>) => void;
+}
+/**
+ * Builds a reusable handler for one capability's incoming capability-grants. The returned function checks, in order: the outer verb names this handler's own capability (otherwise `{result:"error", code:"malformed"}`, matching capability-request.ts's identical check); the params payload parses against capability-grant's own CDDL shape (otherwise "malformed"); the embedded token independently passes every ordinary verifyCapabilityToken obligation with `expectedBearer` set to this receiver's OWN identity -- obligations 1 and 3 together, since an unsolicited push must name its actual recipient as bearer and must otherwise be exactly as valid as any other token (a verification failure responds with verifyCapabilityToken's own specific TokenVerdictReason as the error code, e.g. "expired"/"revoked"/"bad_signature", rather than a single generic code, mirroring how capability-request.ts already distinguishes "expired" from "malformed"); the token's own capability claim equals this handler's capability (obligation 2, otherwise "capability_mismatch"); and the token's own scope equals or roots the enclosing request's own top-level scope (obligation 4, via tokens.ts's own scopeNarrows -- otherwise "scope_mismatch"). Only once every obligation passes does it respond `{result:"ok"}` and invoke onGrant -- there is no decide()/timeout mechanism the way createCapabilityRequestHandler has one, since management.cddl specifies no protocol-level approval round trip for this primitive at all.
+ */
+export declare function createCapabilityGrantHandler(options: Readonly<CreateCapabilityGrantHandlerOptions>): (incoming: Readonly<IncomingManageRequest>) => Promise<void>;
+//#endregion

package/dist/domain/capability-grant.d.mts

@@ -0,0 +1,44 @@
+import { F as ManageCommand, o as CapabilityScope, s as CapabilityToken, x as DeviceId } from "../protocol-Dhswk7YD.mjs";
+import { t as IdentityPort } from "../identity-B1hBV3YA.mjs";
+import { t as Clock } from "../clock-DiSx-WKM.mjs";
+import { IncomingManageRequest, ManageOutcome, MeshSession } from "./mesh-session.mjs";
+import { RevocationCheck } from "./tokens.mjs";
+//#region src/domain/capability-grant.d.ts
+/**
+ * Builds a capability-grant command per management.cddl. The outer `manage-command.verb` is the capability string itself, the identical convention capability-request.ts's own buildCapabilityRequestCommand already establishes -- a receiver's per-capability handler is how it knows which grant this push is even for. `params.verb` is the fixed "capability.grant" marker. No scope or invitee field: manage-request-frame's own top-level scope already carries the former, and the request's own destination already carries the latter -- naming either a second time inside params could only ever disagree with the fact it duplicates.
+ */
+export declare function buildCapabilityGrantCommand(capability: string, grantedToken: CapabilityToken): ManageCommand;
+/**
+ * Pushes an already-minted grantedToken to whichever peer this request is addressed to -- the caller mints grantedToken itself beforehand (there is no minting step here, unlike capability-request's own accept path, since this primitive carries a token the sender already decided to hand over unprompted). Resolves with the raw manage-response outcome: `{result:"ok"}` on successful validation, an ordinary manage-error otherwise (per management.cddl's own capability-grant obligations, this is a validation-failure code only, never a human "no" -- an application wanting a human-decision gate applies it on the RECEIVING side's own onGrant callback instead, exactly as core/room's own room.invite→room_invite delivery event already does today in agent-comms).
+ *
+ * scope and targetDevice forward directly to MeshSession.sendManageRequest's own identically-named parameters (the request's own top-level scope obligation 4 checks the token against, and relay routing respectively).
+ */
+export declare function sendCapabilityGrant(session: Readonly<MeshSession>, capability: string, grantedToken: CapabilityToken, scope: Readonly<CapabilityScope>, targetDevice?: DeviceId): Promise<ManageOutcome>;
+/** One incoming, fully-verified capability-grant, surfaced for the domain to react to (store the token, notify a human, etc.) -- there is no decide() here because management.cddl specifies no protocol-level approval round trip for this primitive; by the time onGrant fires, the wire response has already been sent. */
+export interface CapabilityGrantEvent {
+  /** The capability granted -- equals both the outer manage-command.verb and the verified token's own capability claim (obligation 2 already enforced this before onGrant fires). */
+  capability: string;
+  /** The pushed token, already confirmed to independently pass every ordinary verifyCapabilityToken obligation, name this receiver as its own bearer, and scope-match the enclosing request (obligations 1, 2, 3, and 4 respectively). Ready to use exactly as capability-request.ts's own CapabilityGrantOk["granted-token"] is on the pull side. */
+  grantedToken: CapabilityToken;
+  /** The scope this grant's own manage-request-frame carried -- e.g. core/room's `{kind:"room", path: roomPath}` -- passed through unchanged so the domain can inspect it (a room handler reads `.path` back out) without this module needing to know its shape. */
+  scope: Readonly<CapabilityScope>;
+  /** The peer device-id authenticated on the connection this grant arrived on -- the granter, surfaced so the domain can attribute the push (e.g. core/room's own room_invite event names the inviter). Never itself checked against the token's bearer (obligation 1 checks the RECIPIENT's own identity instead -- an unsolicited push names its own recipient by where it was sent, not by who sent it). */
+  granterDevice: DeviceId;
+}
+export interface CreateCapabilityGrantHandlerOptions {
+  /** The capability this handler accepts pushed grants for. Checked against the incoming command's own outer verb (a mismatch is refused as malformed, mirroring capability-request.ts's identical capability check) and against the verified token's own capability claim (obligation 2); a caller wanting to accept grants for several distinct capabilities over one session constructs one handler per capability, the same way core/room constructs one handler for `room:member` and nothing else. */
+  capability: string;
+  /** This receiver's own identity -- both the verification primitives every pushed token is checked with, and (via `.deviceId`) the value obligation 1 requires the token's own bearer to equal. There is no separate bearerDevice option the way CreateCapabilityRequestHandlerOptions has one: capability-request's handler mints a NEW token for whichever peer asked, so it needs that peer's device-id as an input; capability-grant's handler verifies an ALREADY-minted token against this side's own identity, which identity.deviceId already provides. */
+  identity: IdentityPort;
+  clock: Clock;
+  revocation: RevocationCheck;
+  /** The peer device-id authenticated on this session's own connection -- the granter, surfaced on every CapabilityGrantEvent so the domain can attribute the push. Never used for verification itself (see CapabilityGrantEvent.granterDevice's own doc comment on why obligation 1 checks the recipient's identity instead). */
+  granterDevice: DeviceId;
+  /** Called once per incoming, fully-verified capability-grant. Fires after the wire response has already been sent (see createCapabilityGrantHandler's own doc comment) -- this is a notification, not a decision point. */
+  onGrant: (event: Readonly<CapabilityGrantEvent>) => void;
+}
+/**
+ * Builds a reusable handler for one capability's incoming capability-grants. The returned function checks, in order: the outer verb names this handler's own capability (otherwise `{result:"error", code:"malformed"}`, matching capability-request.ts's identical check); the params payload parses against capability-grant's own CDDL shape (otherwise "malformed"); the embedded token independently passes every ordinary verifyCapabilityToken obligation with `expectedBearer` set to this receiver's OWN identity -- obligations 1 and 3 together, since an unsolicited push must name its actual recipient as bearer and must otherwise be exactly as valid as any other token (a verification failure responds with verifyCapabilityToken's own specific TokenVerdictReason as the error code, e.g. "expired"/"revoked"/"bad_signature", rather than a single generic code, mirroring how capability-request.ts already distinguishes "expired" from "malformed"); the token's own capability claim equals this handler's capability (obligation 2, otherwise "capability_mismatch"); and the token's own scope equals or roots the enclosing request's own top-level scope (obligation 4, via tokens.ts's own scopeNarrows -- otherwise "scope_mismatch"). Only once every obligation passes does it respond `{result:"ok"}` and invoke onGrant -- there is no decide()/timeout mechanism the way createCapabilityRequestHandler has one, since management.cddl specifies no protocol-level approval round trip for this primitive at all.
+ */
+export declare function createCapabilityGrantHandler(options: Readonly<CreateCapabilityGrantHandlerOptions>): (incoming: Readonly<IncomingManageRequest>) => Promise<void>;
+//#endregion

package/dist/domain/capability-grant.mjs

@@ -0,0 +1,87 @@
+import { capabilityGrantSchema } from "../generated/protocol.mjs";
+import { scopeNarrows, verifyCapabilityToken } from "./tokens.mjs";
+//#region src/domain/capability-grant.ts
+/**
+* The generic, capability-agnostic capability-grant primitive (wire-mesh#117, spec/management.cddl) -- the unsolicited push counterpart to capability-request.ts's own ask/response primitive. Where capability-request lifts core/room's room.join shape (a pull: the requester asks, the owner mints and returns a grant on the same response) out of that one domain, capability-grant lifts room.invite's own shape (a push: the owner mints unprompted and delivers the grant in the request itself, since there is no approval round-trip to carry it back) the same way. core/room's own room-client.ts is the reference consumer: it builds sendRoomInvite as a thin wrapper over sendCapabilityGrant below, and wires createRoomRouter's dispatch onto createCapabilityGrantHandler for the receiving side.
+*
+* Two responsibilities, split the same way capability-request.ts already splits them: sendCapabilityGrant is the pushing side (a thin wrapper over MeshSession.sendManageRequest), and createCapabilityGrantHandler is the receiving side (validates the pushed token against all four of management.cddl's own capability-grant obligations, then hands the verified grant to the domain). Unlike capability-request's handler, there is no decide()/timeout mechanism here: management.cddl deliberately specifies no protocol-level approval round trip for this primitive (a receiver's manage-response reports validation success or failure only, never a human decision), so onGrant is a plain notification callback, not an event carrying its own responder.
+*/
+/**
+* Builds a capability-grant command per management.cddl. The outer `manage-command.verb` is the capability string itself, the identical convention capability-request.ts's own buildCapabilityRequestCommand already establishes -- a receiver's per-capability handler is how it knows which grant this push is even for. `params.verb` is the fixed "capability.grant" marker. No scope or invitee field: manage-request-frame's own top-level scope already carries the former, and the request's own destination already carries the latter -- naming either a second time inside params could only ever disagree with the fact it duplicates.
+*/
+function buildCapabilityGrantCommand(capability, grantedToken) {
+	return {
+		verb: capability,
+		params: {
+			verb: "capability.grant",
+			"granted-token": grantedToken
+		}
+	};
+}
+/**
+* Pushes an already-minted grantedToken to whichever peer this request is addressed to -- the caller mints grantedToken itself beforehand (there is no minting step here, unlike capability-request's own accept path, since this primitive carries a token the sender already decided to hand over unprompted). Resolves with the raw manage-response outcome: `{result:"ok"}` on successful validation, an ordinary manage-error otherwise (per management.cddl's own capability-grant obligations, this is a validation-failure code only, never a human "no" -- an application wanting a human-decision gate applies it on the RECEIVING side's own onGrant callback instead, exactly as core/room's own room.invite→room_invite delivery event already does today in agent-comms).
+*
+* scope and targetDevice forward directly to MeshSession.sendManageRequest's own identically-named parameters (the request's own top-level scope obligation 4 checks the token against, and relay routing respectively).
+*/
+async function sendCapabilityGrant(session, capability, grantedToken, scope, targetDevice) {
+	return session.sendManageRequest(buildCapabilityGrantCommand(capability, grantedToken), scope, targetDevice);
+}
+/**
+* Builds a reusable handler for one capability's incoming capability-grants. The returned function checks, in order: the outer verb names this handler's own capability (otherwise `{result:"error", code:"malformed"}`, matching capability-request.ts's identical check); the params payload parses against capability-grant's own CDDL shape (otherwise "malformed"); the embedded token independently passes every ordinary verifyCapabilityToken obligation with `expectedBearer` set to this receiver's OWN identity -- obligations 1 and 3 together, since an unsolicited push must name its actual recipient as bearer and must otherwise be exactly as valid as any other token (a verification failure responds with verifyCapabilityToken's own specific TokenVerdictReason as the error code, e.g. "expired"/"revoked"/"bad_signature", rather than a single generic code, mirroring how capability-request.ts already distinguishes "expired" from "malformed"); the token's own capability claim equals this handler's capability (obligation 2, otherwise "capability_mismatch"); and the token's own scope equals or roots the enclosing request's own top-level scope (obligation 4, via tokens.ts's own scopeNarrows -- otherwise "scope_mismatch"). Only once every obligation passes does it respond `{result:"ok"}` and invoke onGrant -- there is no decide()/timeout mechanism the way createCapabilityRequestHandler has one, since management.cddl specifies no protocol-level approval round trip for this primitive at all.
+*/
+function createCapabilityGrantHandler(options) {
+	return async function handleCapabilityGrant(incoming) {
+		if (incoming.command.verb !== options.capability) {
+			await incoming.respond({
+				result: "error",
+				code: "malformed"
+			});
+			return;
+		}
+		const parsed = capabilityGrantSchema.safeParse(incoming.command.params);
+		if (!parsed.success) {
+			await incoming.respond({
+				result: "error",
+				code: "malformed"
+			});
+			return;
+		}
+		const grantedToken = parsed.data["granted-token"];
+		const verdict = await verifyCapabilityToken(grantedToken, {
+			identity: options.identity,
+			clock: options.clock,
+			revocation: options.revocation,
+			expectedBearer: options.identity.deviceId
+		});
+		if (!verdict.ok) {
+			await incoming.respond({
+				result: "error",
+				code: verdict.reason
+			});
+			return;
+		}
+		if (verdict.claims.capability !== options.capability) {
+			await incoming.respond({
+				result: "error",
+				code: "capability_mismatch"
+			});
+			return;
+		}
+		if (!scopeNarrows(verdict.claims.scope, incoming.scope)) {
+			await incoming.respond({
+				result: "error",
+				code: "scope_mismatch"
+			});
+			return;
+		}
+		await incoming.respond({ result: "ok" });
+		options.onGrant({
+			capability: options.capability,
+			grantedToken,
+			scope: incoming.scope,
+			granterDevice: options.granterDevice
+		});
+	};
+}
+//#endregion
+export { buildCapabilityGrantCommand, createCapabilityGrantHandler, sendCapabilityGrant };

package/dist/domain/capability-request.d.cts

@@ -1,5 +1,5 @@
-import { P as ManageCommand, a as CapabilityScope, b as DeviceId, r as CapabilityGrantOk } from "../protocol-MnxTzpRP.cjs";
-import { t as IdentityPort } from "../identity-DkEe1465.cjs";
+import { F as ManageCommand, i as CapabilityGrantOk, o as CapabilityScope, x as DeviceId } from "../protocol-Dhswk7YD.cjs";
+import { t as IdentityPort } from "../identity-BldV8xFj.cjs";
 import { t as Clock } from "../clock-DiSx-WKM.cjs";
 import { IncomingManageRequest, MeshSession } from "./mesh-session.cjs";
 //#region src/domain/capability-request.d.ts

package/dist/domain/capability-request.d.mts

@@ -1,5 +1,5 @@
-import { P as ManageCommand, a as CapabilityScope, b as DeviceId, r as CapabilityGrantOk } from "../protocol-MnxTzpRP.mjs";
-import { t as IdentityPort } from "../identity-D8iJZRZZ.mjs";
+import { F as ManageCommand, i as CapabilityGrantOk, o as CapabilityScope, x as DeviceId } from "../protocol-Dhswk7YD.mjs";
+import { t as IdentityPort } from "../identity-B1hBV3YA.mjs";
 import { t as Clock } from "../clock-DiSx-WKM.mjs";
 import { IncomingManageRequest, MeshSession } from "./mesh-session.mjs";
 //#region src/domain/capability-request.d.ts

package/dist/domain/device-id.d.cts

@@ -1,4 +1,4 @@
-import { b as DeviceId } from "../protocol-MnxTzpRP.cjs";
+import { x as DeviceId } from "../protocol-Dhswk7YD.cjs";
 //#region src/domain/device-id.d.ts
 /** Lowercase, byte-exact hex for an arbitrary-length byte string -- the same encoding convention deviceIdToHex uses for the fixed-length device-id case, extracted so any other byte string needing a stable, displayable, map-keyable text form (e.g. a token-id, which tokens.cddl defines as an arbitrary-length bstr rather than a 32-byte device-id) can use the identical convention without going through a device-id-shaped function. */
 export declare function bytesToHex(bytes: Uint8Array): string;

package/dist/domain/device-id.d.mts

@@ -1,4 +1,4 @@
-import { b as DeviceId } from "../protocol-MnxTzpRP.mjs";
+import { x as DeviceId } from "../protocol-Dhswk7YD.mjs";
 //#region src/domain/device-id.d.ts
 /** Lowercase, byte-exact hex for an arbitrary-length byte string -- the same encoding convention deviceIdToHex uses for the fixed-length device-id case, extracted so any other byte string needing a stable, displayable, map-keyable text form (e.g. a token-id, which tokens.cddl defines as an arbitrary-length bstr rather than a 32-byte device-id) can use the identical convention without going through a device-id-shaped function. */
 export declare function bytesToHex(bytes: Uint8Array): string;

package/dist/domain/handshake.d.cts

@@ -1,4 +1,4 @@
-import { $ as ProtocolVersion, C as DomainId, j as HandshakeFrame } from "../protocol-MnxTzpRP.cjs";
+import { M as HandshakeFrame, et as ProtocolVersion, w as DomainId } from "../protocol-Dhswk7YD.cjs";
 //#region src/domain/handshake.d.ts
 /** The highest protocol version this build of core understands. */
 export declare const SUPPORTED_PROTOCOL_VERSION: ProtocolVersion;

package/dist/domain/handshake.d.mts

@@ -1,4 +1,4 @@
-import { $ as ProtocolVersion, C as DomainId, j as HandshakeFrame } from "../protocol-MnxTzpRP.mjs";
+import { M as HandshakeFrame, et as ProtocolVersion, w as DomainId } from "../protocol-Dhswk7YD.mjs";
 //#region src/domain/handshake.d.ts
 /** The highest protocol version this build of core understands. */
 export declare const SUPPORTED_PROTOCOL_VERSION: ProtocolVersion;

package/dist/domain/mesh-session.d.cts

@@ -1,7 +1,7 @@
-import { $ as ProtocolVersion, E as Frame, G as PeerAdvert, I as ManageError, L as ManageOk, P as ManageCommand, a as CapabilityScope, b as DeviceId, o as CapabilityToken, ut as RevocationEntry } from "../protocol-MnxTzpRP.cjs";
-import { t as IdentityPort } from "../identity-DkEe1465.cjs";
+import { D as Frame, F as ManageCommand, K as PeerAdvert, L as ManageError, R as ManageOk, dt as RevocationEntry, et as ProtocolVersion, o as CapabilityScope, s as CapabilityToken, x as DeviceId } from "../protocol-Dhswk7YD.cjs";
+import { t as IdentityPort } from "../identity-BldV8xFj.cjs";
 import { t as Clock } from "../clock-DiSx-WKM.cjs";
-import { r as Transport, t as Connection } from "../transport-Da7GP9ya.cjs";
+import { r as Transport, t as Connection } from "../transport-hEUxrdhT.cjs";
 //#region src/domain/mesh-session.d.ts
 /** How long to wait for the node's handshake before calling it unanswered. A relay-only node never sends one; that is a state to display, not an error. */
 export declare const HANDSHAKE_TIMEOUT_MS = 3000;

package/dist/domain/mesh-session.d.mts

@@ -1,7 +1,7 @@
-import { $ as ProtocolVersion, E as Frame, G as PeerAdvert, I as ManageError, L as ManageOk, P as ManageCommand, a as CapabilityScope, b as DeviceId, o as CapabilityToken, ut as RevocationEntry } from "../protocol-MnxTzpRP.mjs";
-import { t as IdentityPort } from "../identity-D8iJZRZZ.mjs";
+import { D as Frame, F as ManageCommand, K as PeerAdvert, L as ManageError, R as ManageOk, dt as RevocationEntry, et as ProtocolVersion, o as CapabilityScope, s as CapabilityToken, x as DeviceId } from "../protocol-Dhswk7YD.mjs";
+import { t as IdentityPort } from "../identity-B1hBV3YA.mjs";
 import { t as Clock } from "../clock-DiSx-WKM.mjs";
-import { r as Transport, t as Connection } from "../transport-ESMXRz3s.mjs";
+import { r as Transport, t as Connection } from "../transport-BNNdUBq-.mjs";
 //#region src/domain/mesh-session.d.ts
 /** How long to wait for the node's handshake before calling it unanswered. A relay-only node never sends one; that is a state to display, not an error. */
 export declare const HANDSHAKE_TIMEOUT_MS = 3000;

package/dist/domain/relay-hub.d.cts

@@ -1,4 +1,4 @@
-import { t as Connection } from "../transport-Da7GP9ya.cjs";
+import { t as Connection } from "../transport-hEUxrdhT.cjs";
 //#region src/domain/relay-hub.d.ts
 export interface RelayHub {
   /** Drives one accepted connection until it closes: registers gossip-advertised devices, answers relay-connect by pairing and notifying the target, and forwards relay-data within established pairings. Resolves when the connection's frame stream ends. */

package/dist/domain/relay-hub.d.mts

@@ -1,4 +1,4 @@
-import { t as Connection } from "../transport-ESMXRz3s.mjs";
+import { t as Connection } from "../transport-BNNdUBq-.mjs";
 //#region src/domain/relay-hub.d.ts
 export interface RelayHub {
   /** Drives one accepted connection until it closes: registers gossip-advertised devices, answers relay-connect by pairing and notifying the target, and forwards relay-data within established pairings. Resolves when the connection's frame stream ends. */

package/dist/domain/revocation-view.d.cts

@@ -1,4 +1,4 @@
-import { ut as RevocationEntry } from "../protocol-MnxTzpRP.cjs";
+import { dt as RevocationEntry } from "../protocol-Dhswk7YD.cjs";
 import { RevocationCheck, RevocationEntryVerdict, VerifyRevocationEntryOptions } from "./tokens.cjs";
 //#region src/domain/revocation-view.d.ts
 /**

package/dist/domain/revocation-view.d.mts

@@ -1,4 +1,4 @@
-import { ut as RevocationEntry } from "../protocol-MnxTzpRP.mjs";
+import { dt as RevocationEntry } from "../protocol-Dhswk7YD.mjs";
 import { RevocationCheck, RevocationEntryVerdict, VerifyRevocationEntryOptions } from "./tokens.mjs";
 //#region src/domain/revocation-view.d.ts
 /**

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

@@ -1,4 +1,4 @@
-import { Ot as TokenClaims, b as DeviceId, o as CapabilityToken } from "../protocol-MnxTzpRP.cjs";
+import { kt as TokenClaims, s as CapabilityToken, x as DeviceId } from "../protocol-Dhswk7YD.cjs";
 import { TokenVerdictReason, VerifyCapabilityTokenOptions } from "./tokens.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. */

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

@@ -1,4 +1,4 @@
-import { Ot as TokenClaims, b as DeviceId, o as CapabilityToken } from "../protocol-MnxTzpRP.mjs";
+import { kt as TokenClaims, s as CapabilityToken, x as DeviceId } from "../protocol-Dhswk7YD.mjs";
 import { TokenVerdictReason, VerifyCapabilityTokenOptions } from "./tokens.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. */

package/dist/domain/tokens.cjs

@@ -20,7 +20,7 @@ function pathNarrows(childPath, parentPath) {
 	return childPath.charAt(parentPath.length) === "/";
 }
 /**
-* True when childScope narrows parentScope per tokens.cddl ("each hop can only narrow authority, never widen it"): the kind must be identical (a different kind is a different kind of authority, not a narrower one), and a parent with a path requires the child to carry an equal-or-descendant path -- an absent child path means the kind's whole-scope root, which is wider than any path-narrowed parent. A parent with no path (whole-scope root) lets any child path under the same kind through.
+* True when childScope narrows parentScope per tokens.cddl ("each hop can only narrow authority, never widen it"): the kind must be identical (a different kind is a different kind of authority, not a narrower one), and a parent with a path requires the child to carry an equal-or-descendant path -- an absent child path means the kind's whole-scope root, which is wider than any path-narrowed parent. A parent with no path (whole-scope root) lets any child path under the same kind through. Exported for capability-grant.ts's own obligation 4 (an unsolicited push's embedded token must equal-or-root the enclosing request's own scope), which is exactly this same narrowing relation applied outside a delegation chain.
 */
 function scopeNarrows(parent, child) {
 	if (parent.kind !== child.kind) return false;
@@ -311,5 +311,6 @@ async function mintRevocationEntry(options) {
 exports.canGrant = canGrant;
 exports.mintCapabilityToken = mintCapabilityToken;
 exports.mintRevocationEntry = mintRevocationEntry;
+exports.scopeNarrows = scopeNarrows;
 exports.verifyCapabilityToken = verifyCapabilityToken;
 exports.verifyRevocationEntry = verifyRevocationEntry;

package/dist/domain/tokens.d.cts

@@ -1,5 +1,5 @@
-import { Ot as TokenClaims, b as DeviceId, lt as RevocationClaims, o as CapabilityToken, ut as RevocationEntry } from "../protocol-MnxTzpRP.cjs";
-import { t as IdentityPort } from "../identity-DkEe1465.cjs";
+import { dt as RevocationEntry, kt as TokenClaims, s as CapabilityToken, ut as RevocationClaims, x as DeviceId } from "../protocol-Dhswk7YD.cjs";
+import { t as IdentityPort } from "../identity-BldV8xFj.cjs";
 import { t as Clock } from "../clock-DiSx-WKM.cjs";
 //#region src/domain/tokens.d.ts
 /**
@@ -27,6 +27,10 @@ export interface VerifyCapabilityTokenOptions {
   /** When given, the token must bear this device -- the caller presenting a token to authorise itself, not someone else. */
   expectedBearer?: DeviceId;
 }
+/**
+ * True when childScope narrows parentScope per tokens.cddl ("each hop can only narrow authority, never widen it"): the kind must be identical (a different kind is a different kind of authority, not a narrower one), and a parent with a path requires the child to carry an equal-or-descendant path -- an absent child path means the kind's whole-scope root, which is wider than any path-narrowed parent. A parent with no path (whole-scope root) lets any child path under the same kind through. Exported for capability-grant.ts's own obligation 4 (an unsolicited push's embedded token must equal-or-root the enclosing request's own scope), which is exactly this same narrowing relation applied outside a delegation chain.
+ */
+export declare function scopeNarrows(parent: TokenClaims["scope"], child: TokenClaims["scope"]): boolean;
 /**
  * Verifies one capability token per tokens.cddl's own documented rules: the token is a well-formed COSE_Sign1 whose signature actually verifies against its own embedded issuer-key, that issuer-key is self-certifying (sha256(issuer-key.public-key) equals the claimed issuer device-id -- no shared secret needed to check this), the token is currently valid (not expired, not before not-before, not revoked by its own issuer), and -- recursively -- any parent delegation narrows rather than widens across all three axes of authority: the parent's bearer must be this token's issuer (the delegation chain is unbroken), this token's expiry must not exceed its parent's, and this token's scope must narrow its parent's (same kind; equal-or-descendant path when the parent carries one) with an identical capability verb (the capability-verb grammar has no sub-verb relation, so a different verb is a different authority, not a narrower one). Undecodable payload bytes return "malformed" and undecodable parent bytes return "parent_invalid" -- hostile input produces a verdict, never a throw.
  */

package/dist/domain/tokens.d.mts

@@ -1,5 +1,5 @@
-import { Ot as TokenClaims, b as DeviceId, lt as RevocationClaims, o as CapabilityToken, ut as RevocationEntry } from "../protocol-MnxTzpRP.mjs";
-import { t as IdentityPort } from "../identity-D8iJZRZZ.mjs";
+import { dt as RevocationEntry, kt as TokenClaims, s as CapabilityToken, ut as RevocationClaims, x as DeviceId } from "../protocol-Dhswk7YD.mjs";
+import { t as IdentityPort } from "../identity-B1hBV3YA.mjs";
 import { t as Clock } from "../clock-DiSx-WKM.mjs";
 //#region src/domain/tokens.d.ts
 /**
@@ -27,6 +27,10 @@ export interface VerifyCapabilityTokenOptions {
   /** When given, the token must bear this device -- the caller presenting a token to authorise itself, not someone else. */
   expectedBearer?: DeviceId;
 }
+/**
+ * True when childScope narrows parentScope per tokens.cddl ("each hop can only narrow authority, never widen it"): the kind must be identical (a different kind is a different kind of authority, not a narrower one), and a parent with a path requires the child to carry an equal-or-descendant path -- an absent child path means the kind's whole-scope root, which is wider than any path-narrowed parent. A parent with no path (whole-scope root) lets any child path under the same kind through. Exported for capability-grant.ts's own obligation 4 (an unsolicited push's embedded token must equal-or-root the enclosing request's own scope), which is exactly this same narrowing relation applied outside a delegation chain.
+ */
+export declare function scopeNarrows(parent: TokenClaims["scope"], child: TokenClaims["scope"]): boolean;
 /**
  * Verifies one capability token per tokens.cddl's own documented rules: the token is a well-formed COSE_Sign1 whose signature actually verifies against its own embedded issuer-key, that issuer-key is self-certifying (sha256(issuer-key.public-key) equals the claimed issuer device-id -- no shared secret needed to check this), the token is currently valid (not expired, not before not-before, not revoked by its own issuer), and -- recursively -- any parent delegation narrows rather than widens across all three axes of authority: the parent's bearer must be this token's issuer (the delegation chain is unbroken), this token's expiry must not exceed its parent's, and this token's scope must narrow its parent's (same kind; equal-or-descendant path when the parent carries one) with an identical capability verb (the capability-verb grammar has no sub-verb relation, so a different verb is a different authority, not a narrower one). Undecodable payload bytes return "malformed" and undecodable parent bytes return "parent_invalid" -- hostile input produces a verdict, never a throw.
  */

package/dist/domain/tokens.mjs

@@ -19,7 +19,7 @@ function pathNarrows(childPath, parentPath) {
 	return childPath.charAt(parentPath.length) === "/";
 }
 /**
-* True when childScope narrows parentScope per tokens.cddl ("each hop can only narrow authority, never widen it"): the kind must be identical (a different kind is a different kind of authority, not a narrower one), and a parent with a path requires the child to carry an equal-or-descendant path -- an absent child path means the kind's whole-scope root, which is wider than any path-narrowed parent. A parent with no path (whole-scope root) lets any child path under the same kind through.
+* True when childScope narrows parentScope per tokens.cddl ("each hop can only narrow authority, never widen it"): the kind must be identical (a different kind is a different kind of authority, not a narrower one), and a parent with a path requires the child to carry an equal-or-descendant path -- an absent child path means the kind's whole-scope root, which is wider than any path-narrowed parent. A parent with no path (whole-scope root) lets any child path under the same kind through. Exported for capability-grant.ts's own obligation 4 (an unsolicited push's embedded token must equal-or-root the enclosing request's own scope), which is exactly this same narrowing relation applied outside a delegation chain.
 */
 function scopeNarrows(parent, child) {
 	if (parent.kind !== child.kind) return false;
@@ -307,4 +307,4 @@ async function mintRevocationEntry(options) {
 	];
 }
 //#endregion
-export { canGrant, mintCapabilityToken, mintRevocationEntry, verifyCapabilityToken, verifyRevocationEntry };
+export { canGrant, mintCapabilityToken, mintRevocationEntry, scopeNarrows, verifyCapabilityToken, verifyRevocationEntry };

package/dist/generated/protocol.cjs

@@ -40,6 +40,7 @@ const manageCommandParamsSchema = zod.z.lazy(() => zod.z.union([
 	]),
 	zod.z.object({}).catchall(zod.z.unknown()),
 	zod.z.lazy(() => capabilityRequestSchema),
+	zod.z.lazy(() => capabilityGrantSchema),
 	zod.z.union([
 		zod.z.lazy(() => roomSendSchema),
 		zod.z.lazy(() => roomReadSchema),
@@ -187,6 +188,10 @@ const capabilityGrantOkSchema = zod.z.lazy(() => zod.z.object({
 	"result": zod.z.literal("ok"),
 	"granted-token": zod.z.lazy(() => capabilityTokenSchema)
 }).catchall(zod.z.unknown()));
+const capabilityGrantSchema = zod.z.lazy(() => zod.z.object({
+	"verb": zod.z.literal("capability.grant"),
+	"granted-token": zod.z.lazy(() => capabilityTokenSchema)
+}).catchall(zod.z.unknown()));
 const revocationClaimsSchema = zod.z.lazy(() => zod.z.object({
 	"token-id": zod.z.instanceof(Uint8Array),
 	"issuer": zod.z.lazy(() => deviceIdSchema),
@@ -395,6 +400,7 @@ const iceCandidateInitSchema = zod.z.lazy(() => zod.z.object({
 exports.candidateKindSchema = candidateKindSchema;
 exports.candidatesFrameSchema = candidatesFrameSchema;
 exports.capabilityGrantOkSchema = capabilityGrantOkSchema;
+exports.capabilityGrantSchema = capabilityGrantSchema;
 exports.capabilityRequestSchema = capabilityRequestSchema;
 exports.capabilityScopeSchema = capabilityScopeSchema;
 exports.capabilityTokenSchema = capabilityTokenSchema;

package/dist/generated/protocol.d.cts

@@ -1,2 +1,2 @@
-import { $ as ProtocolVersion, $n as roomReadSchema, $t as deviceIdSchema, A as HandleRecord, An as procSpawnSchema, At as WebrtcIceCandidate, B as MessageRef, Bn as revocationAnnounceFrameSchema, Bt as closeFrameSchema, C as DomainId, Cn as peerAdvertSchema, Ct as StreamAckFrame, D as FrameVariant, Dn as privateUseDomainIdSchema, Dt as SyncPunchFrame, E as Frame, En as privateUseCapabilitySchema, Et as StreamSession, F as ManageCommandParams, Fn as ptyWriteSchema, Ft as capabilityGrantOkSchema, G as PeerAdvert, Gn as roomJoinSchema, Gt as coseHeaderKidSchema, H as NamespacedDomainId, Hn as revocationEntrySchema, Ht as coreCapabilitySchema, I as ManageError, In as relayConnectFrameSchema, It as capabilityRequestSchema, J as PrivateUseCapability, Jn as roomMembersOkSchema, Jt as coseTokenHeadersSchema, K as PeerIdentity, Kn as roomLeaveSchema, Kt as coseHeaderLabelSchema, L as ManageOk, Ln as relayDataFrameSchema, Lt as capabilityScopeSchema, M as IceCandidateInit, Mn as ptyKillSchema, Mt as WireCandidate, N as IdentityKey, Nn as ptyResizeSchema, Nt as candidateKindSchema, O as GossipFrame, On as procKillSchema, Ot as TokenClaims, P as ManageCommand, Pn as ptySpawnSchema, Pt as candidatesFrameSchema, Q as ProcSpawn, Qn as roomPathSchema, Qt as deviceIdHexSchema, R as ManageRequestFrame, Rn as relayInboundFrameSchema, Rt as capabilityTokenSchema, S as DmRoomPath, Sn as ownerNamedRoomPathSchema, St as RoomSend, T as ExecSessionInfo, Tn as pingFrameSchema, Tt as StreamEndFrame, U as ObservedAddressFrame, Un as roomInviteSchema, Ut as coreDomainNameSchema, V as NamespacedCapability, Vn as revocationClaimsSchema, Vt as coordinatorFrameSchema, W as OwnerNamedRoomPath, Wn as roomJoinOkSchema, Wt as coseHeaderAlgSchema, X as ProcKill, Xn as roomNoticeClaimsSchema, Xt as dataHaveFrameSchema, Y as PrivateUseDomainId, Yn as roomMembersSchema, Yt as dataEntriesFrameSchema, Z as ProcSignal, Zn as roomNoticeSchema, Zt as dataRequestFrameSchema, _ as DataEntriesFrame, _n as manageResponseFrameSchema, _t as RoomMembersOk, a as CapabilityScope, an as frameVariantSchema, ar as syncPunchFrameSchema, at as RelayDataFrame, b as DeviceId, bn as namespacedDomainIdSchema, bt as RoomPath, c as CloseFrame, cn as handleRecordSchema, cr as webrtcIceCandidateSchema, ct as RevocationAnnounceFrame, d as CoreDomainName, dn as identityKeySchema, dt as RoomInvite, en as dmRoomPathSchema, er as roomSendSchema, et as PtyKill, f as CoseHeaderAlg, fn as manageCommandParamsSchema, ft as RoomJoin, g as CoseTokenHeaders, gn as manageRequestFrameSchema, gt as RoomMembers, h as CoseSign1, hn as manageOkSchema, ht as RoomMember, i as CapabilityRequest, in as frameSchema, ir as streamSessionSchema, it as RelayConnectFrame, j as HandshakeFrame, jn as protocolVersionSchema, jt as WebrtcOffer, k as HandleClaims, kn as procSignalSchema, kt as WebrtcAnswer, l as CoordinatorFrame, ln as handshakeFrameSchema, lr as webrtcOfferSchema, lt as RevocationClaims, m as CoseHeaderLabel, mn as manageErrorSchema, mt as RoomLeave, n as CandidatesFrame, nn as execListSchema, nr as streamDataFrameSchema, nt as PtySpawn, o as CapabilityToken, on as gossipFrameSchema, or as tokenClaimsSchema, ot as RelayInboundFrame, p as CoseHeaderKid, pn as manageCommandSchema, pt as RoomJoinOk, q as PingFrame, qn as roomMemberSchema, qt as coseSign1Schema, r as CapabilityGrantOk, rn as execSessionInfoSchema, rr as streamEndFrameSchema, rt as PtyWrite, s as CapabilityVerb, sn as handleClaimsSchema, sr as webrtcAnswerSchema, st as RelayOfferFrame, t as CandidateKind, tn as domainIdSchema, tr as streamAckFrameSchema, tt as PtyResize, u as CoreCapability, un as iceCandidateInitSchema, ur as wireCandidateSchema, ut as RevocationEntry, v as DataHaveFrame, vn as messageRefSchema, vt as RoomNotice, w as ExecList, wn as peerIdentitySchema, wt as StreamDataFrame, x as DeviceIdHex, xn as observedAddressFrameSchema, xt as RoomRead, y as DataRequestFrame, yn as namespacedCapabilitySchema, yt as RoomNoticeClaims, z as ManageResponseFrame, zn as relayOfferFrameSchema, zt as capabilityVerbSchema } from "../protocol-MnxTzpRP.cjs";
-export { CandidateKind, CandidatesFrame, CapabilityGrantOk, CapabilityRequest, CapabilityScope, CapabilityToken, CapabilityVerb, CloseFrame, CoordinatorFrame, CoreCapability, CoreDomainName, CoseHeaderAlg, CoseHeaderKid, CoseHeaderLabel, CoseSign1, CoseTokenHeaders, DataEntriesFrame, DataHaveFrame, DataRequestFrame, DeviceId, DeviceIdHex, DmRoomPath, DomainId, ExecList, ExecSessionInfo, Frame, FrameVariant, GossipFrame, HandleClaims, HandleRecord, HandshakeFrame, IceCandidateInit, IdentityKey, ManageCommand, ManageCommandParams, ManageError, ManageOk, ManageRequestFrame, ManageResponseFrame, MessageRef, NamespacedCapability, NamespacedDomainId, ObservedAddressFrame, OwnerNamedRoomPath, PeerAdvert, PeerIdentity, PingFrame, PrivateUseCapability, PrivateUseDomainId, ProcKill, ProcSignal, ProcSpawn, ProtocolVersion, PtyKill, PtyResize, PtySpawn, PtyWrite, RelayConnectFrame, RelayDataFrame, RelayInboundFrame, RelayOfferFrame, RevocationAnnounceFrame, RevocationClaims, RevocationEntry, RoomInvite, RoomJoin, RoomJoinOk, RoomLeave, RoomMember, RoomMembers, RoomMembersOk, RoomNotice, RoomNoticeClaims, RoomPath, RoomRead, RoomSend, StreamAckFrame, StreamDataFrame, StreamEndFrame, StreamSession, SyncPunchFrame, TokenClaims, WebrtcAnswer, WebrtcIceCandidate, WebrtcOffer, WireCandidate, candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomSendSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };
+import { $ as ProcSpawn, $n as roomNoticeSchema, $t as dataRequestFrameSchema, A as HandleClaims, An as procKillSchema, At as WebrtcAnswer, B as ManageResponseFrame, Bn as relayInboundFrameSchema, Bt as capabilityTokenSchema, C as DmRoomPath, Cn as observedAddressFrameSchema, Ct as RoomSend, D as Frame, Dn as pingFrameSchema, Dt as StreamSession, E as ExecSessionInfo, En as peerIdentitySchema, Et as StreamEndFrame, F as ManageCommand, Fn as ptyResizeSchema, Ft as candidatesFrameSchema, G as OwnerNamedRoomPath, Gn as roomInviteSchema, Gt as coreDomainNameSchema, H as NamespacedCapability, Hn as revocationAnnounceFrameSchema, Ht as closeFrameSchema, I as ManageCommandParams, In as ptySpawnSchema, It as capabilityGrantOkSchema, J as PingFrame, Jn as roomLeaveSchema, Jt as coseHeaderLabelSchema, K as PeerAdvert, Kn as roomJoinOkSchema, Kt as coseHeaderAlgSchema, L as ManageError, Ln as ptyWriteSchema, Lt as capabilityGrantSchema, M as HandshakeFrame, Mn as procSpawnSchema, Mt as WebrtcOffer, N as IceCandidateInit, Nn as protocolVersionSchema, Nt as WireCandidate, O as FrameVariant, On as privateUseCapabilitySchema, Ot as SyncPunchFrame, P as IdentityKey, Pn as ptyKillSchema, Pt as candidateKindSchema, Q as ProcSignal, Qn as roomNoticeClaimsSchema, Qt as dataHaveFrameSchema, R as ManageOk, Rn as relayConnectFrameSchema, Rt as capabilityRequestSchema, S as DeviceIdHex, Sn as namespacedDomainIdSchema, St as RoomRead, T as ExecList, Tn as peerAdvertSchema, Tt as StreamDataFrame, U as NamespacedDomainId, Un as revocationClaimsSchema, Ut as coordinatorFrameSchema, V as MessageRef, Vn as relayOfferFrameSchema, Vt as capabilityVerbSchema, W as ObservedAddressFrame, Wn as revocationEntrySchema, Wt as coreCapabilitySchema, X as PrivateUseDomainId, Xn as roomMembersOkSchema, Xt as coseTokenHeadersSchema, Y as PrivateUseCapability, Yn as roomMemberSchema, Yt as coseSign1Schema, Z as ProcKill, Zn as roomMembersSchema, Zt as dataEntriesFrameSchema, _ as CoseTokenHeaders, _n as manageOkSchema, _t as RoomMembers, a as CapabilityRequest, an as execSessionInfoSchema, ar as streamEndFrameSchema, at as RelayConnectFrame, b as DataRequestFrame, bn as messageRefSchema, bt as RoomNoticeClaims, c as CapabilityVerb, cn as gossipFrameSchema, cr as tokenClaimsSchema, ct as RelayOfferFrame, d as CoreCapability, dn as handshakeFrameSchema, dr as webrtcOfferSchema, dt as RevocationEntry, en as deviceIdHexSchema, er as roomPathSchema, et as ProtocolVersion, f as CoreDomainName, fn as iceCandidateInitSchema, fr as wireCandidateSchema, ft as RoomInvite, g as CoseSign1, gn as manageErrorSchema, gt as RoomMember, h as CoseHeaderLabel, hn as manageCommandSchema, ht as RoomLeave, i as CapabilityGrantOk, in as execListSchema, ir as streamDataFrameSchema, it as PtyWrite, j as HandleRecord, jn as procSignalSchema, jt as WebrtcIceCandidate, k as GossipFrame, kn as privateUseDomainIdSchema, kt as TokenClaims, l as CloseFrame, ln as handleClaimsSchema, lr as webrtcAnswerSchema, lt as RevocationAnnounceFrame, m as CoseHeaderKid, mn as manageCommandParamsSchema, mt as RoomJoinOk, n as CandidatesFrame, nn as dmRoomPathSchema, nr as roomSendSchema, nt as PtyResize, o as CapabilityScope, on as frameSchema, or as streamSessionSchema, ot as RelayDataFrame, p as CoseHeaderAlg, pn as identityKeySchema, pt as RoomJoin, q as PeerIdentity, qn as roomJoinSchema, qt as coseHeaderKidSchema, r as CapabilityGrant, rn as domainIdSchema, rr as streamAckFrameSchema, rt as PtySpawn, s as CapabilityToken, sn as frameVariantSchema, sr as syncPunchFrameSchema, st as RelayInboundFrame, t as CandidateKind, tn as deviceIdSchema, tr as roomReadSchema, tt as PtyKill, u as CoordinatorFrame, un as handleRecordSchema, ur as webrtcIceCandidateSchema, ut as RevocationClaims, v as DataEntriesFrame, vn as manageRequestFrameSchema, vt as RoomMembersOk, w as DomainId, wn as ownerNamedRoomPathSchema, wt as StreamAckFrame, x as DeviceId, xn as namespacedCapabilitySchema, xt as RoomPath, y as DataHaveFrame, yn as manageResponseFrameSchema, yt as RoomNotice, z as ManageRequestFrame, zn as relayDataFrameSchema, zt as capabilityScopeSchema } from "../protocol-Dhswk7YD.cjs";
+export { CandidateKind, CandidatesFrame, CapabilityGrant, CapabilityGrantOk, CapabilityRequest, CapabilityScope, CapabilityToken, CapabilityVerb, CloseFrame, CoordinatorFrame, CoreCapability, CoreDomainName, CoseHeaderAlg, CoseHeaderKid, CoseHeaderLabel, CoseSign1, CoseTokenHeaders, DataEntriesFrame, DataHaveFrame, DataRequestFrame, DeviceId, DeviceIdHex, DmRoomPath, DomainId, ExecList, ExecSessionInfo, Frame, FrameVariant, GossipFrame, HandleClaims, HandleRecord, HandshakeFrame, IceCandidateInit, IdentityKey, ManageCommand, ManageCommandParams, ManageError, ManageOk, ManageRequestFrame, ManageResponseFrame, MessageRef, NamespacedCapability, NamespacedDomainId, ObservedAddressFrame, OwnerNamedRoomPath, PeerAdvert, PeerIdentity, PingFrame, PrivateUseCapability, PrivateUseDomainId, ProcKill, ProcSignal, ProcSpawn, ProtocolVersion, PtyKill, PtyResize, PtySpawn, PtyWrite, RelayConnectFrame, RelayDataFrame, RelayInboundFrame, RelayOfferFrame, RevocationAnnounceFrame, RevocationClaims, RevocationEntry, RoomInvite, RoomJoin, RoomJoinOk, RoomLeave, RoomMember, RoomMembers, RoomMembersOk, RoomNotice, RoomNoticeClaims, RoomPath, RoomRead, RoomSend, StreamAckFrame, StreamDataFrame, StreamEndFrame, StreamSession, SyncPunchFrame, TokenClaims, WebrtcAnswer, WebrtcIceCandidate, WebrtcOffer, WireCandidate, candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityGrantSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomSendSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };

package/dist/generated/protocol.d.mts

@@ -1,2 +1,2 @@
-import { $ as ProtocolVersion, $n as roomReadSchema, $t as deviceIdSchema, A as HandleRecord, An as procSpawnSchema, At as WebrtcIceCandidate, B as MessageRef, Bn as revocationAnnounceFrameSchema, Bt as closeFrameSchema, C as DomainId, Cn as peerAdvertSchema, Ct as StreamAckFrame, D as FrameVariant, Dn as privateUseDomainIdSchema, Dt as SyncPunchFrame, E as Frame, En as privateUseCapabilitySchema, Et as StreamSession, F as ManageCommandParams, Fn as ptyWriteSchema, Ft as capabilityGrantOkSchema, G as PeerAdvert, Gn as roomJoinSchema, Gt as coseHeaderKidSchema, H as NamespacedDomainId, Hn as revocationEntrySchema, Ht as coreCapabilitySchema, I as ManageError, In as relayConnectFrameSchema, It as capabilityRequestSchema, J as PrivateUseCapability, Jn as roomMembersOkSchema, Jt as coseTokenHeadersSchema, K as PeerIdentity, Kn as roomLeaveSchema, Kt as coseHeaderLabelSchema, L as ManageOk, Ln as relayDataFrameSchema, Lt as capabilityScopeSchema, M as IceCandidateInit, Mn as ptyKillSchema, Mt as WireCandidate, N as IdentityKey, Nn as ptyResizeSchema, Nt as candidateKindSchema, O as GossipFrame, On as procKillSchema, Ot as TokenClaims, P as ManageCommand, Pn as ptySpawnSchema, Pt as candidatesFrameSchema, Q as ProcSpawn, Qn as roomPathSchema, Qt as deviceIdHexSchema, R as ManageRequestFrame, Rn as relayInboundFrameSchema, Rt as capabilityTokenSchema, S as DmRoomPath, Sn as ownerNamedRoomPathSchema, St as RoomSend, T as ExecSessionInfo, Tn as pingFrameSchema, Tt as StreamEndFrame, U as ObservedAddressFrame, Un as roomInviteSchema, Ut as coreDomainNameSchema, V as NamespacedCapability, Vn as revocationClaimsSchema, Vt as coordinatorFrameSchema, W as OwnerNamedRoomPath, Wn as roomJoinOkSchema, Wt as coseHeaderAlgSchema, X as ProcKill, Xn as roomNoticeClaimsSchema, Xt as dataHaveFrameSchema, Y as PrivateUseDomainId, Yn as roomMembersSchema, Yt as dataEntriesFrameSchema, Z as ProcSignal, Zn as roomNoticeSchema, Zt as dataRequestFrameSchema, _ as DataEntriesFrame, _n as manageResponseFrameSchema, _t as RoomMembersOk, a as CapabilityScope, an as frameVariantSchema, ar as syncPunchFrameSchema, at as RelayDataFrame, b as DeviceId, bn as namespacedDomainIdSchema, bt as RoomPath, c as CloseFrame, cn as handleRecordSchema, cr as webrtcIceCandidateSchema, ct as RevocationAnnounceFrame, d as CoreDomainName, dn as identityKeySchema, dt as RoomInvite, en as dmRoomPathSchema, er as roomSendSchema, et as PtyKill, f as CoseHeaderAlg, fn as manageCommandParamsSchema, ft as RoomJoin, g as CoseTokenHeaders, gn as manageRequestFrameSchema, gt as RoomMembers, h as CoseSign1, hn as manageOkSchema, ht as RoomMember, i as CapabilityRequest, in as frameSchema, ir as streamSessionSchema, it as RelayConnectFrame, j as HandshakeFrame, jn as protocolVersionSchema, jt as WebrtcOffer, k as HandleClaims, kn as procSignalSchema, kt as WebrtcAnswer, l as CoordinatorFrame, ln as handshakeFrameSchema, lr as webrtcOfferSchema, lt as RevocationClaims, m as CoseHeaderLabel, mn as manageErrorSchema, mt as RoomLeave, n as CandidatesFrame, nn as execListSchema, nr as streamDataFrameSchema, nt as PtySpawn, o as CapabilityToken, on as gossipFrameSchema, or as tokenClaimsSchema, ot as RelayInboundFrame, p as CoseHeaderKid, pn as manageCommandSchema, pt as RoomJoinOk, q as PingFrame, qn as roomMemberSchema, qt as coseSign1Schema, r as CapabilityGrantOk, rn as execSessionInfoSchema, rr as streamEndFrameSchema, rt as PtyWrite, s as CapabilityVerb, sn as handleClaimsSchema, sr as webrtcAnswerSchema, st as RelayOfferFrame, t as CandidateKind, tn as domainIdSchema, tr as streamAckFrameSchema, tt as PtyResize, u as CoreCapability, un as iceCandidateInitSchema, ur as wireCandidateSchema, ut as RevocationEntry, v as DataHaveFrame, vn as messageRefSchema, vt as RoomNotice, w as ExecList, wn as peerIdentitySchema, wt as StreamDataFrame, x as DeviceIdHex, xn as observedAddressFrameSchema, xt as RoomRead, y as DataRequestFrame, yn as namespacedCapabilitySchema, yt as RoomNoticeClaims, z as ManageResponseFrame, zn as relayOfferFrameSchema, zt as capabilityVerbSchema } from "../protocol-MnxTzpRP.mjs";
-export { CandidateKind, CandidatesFrame, CapabilityGrantOk, CapabilityRequest, CapabilityScope, CapabilityToken, CapabilityVerb, CloseFrame, CoordinatorFrame, CoreCapability, CoreDomainName, CoseHeaderAlg, CoseHeaderKid, CoseHeaderLabel, CoseSign1, CoseTokenHeaders, DataEntriesFrame, DataHaveFrame, DataRequestFrame, DeviceId, DeviceIdHex, DmRoomPath, DomainId, ExecList, ExecSessionInfo, Frame, FrameVariant, GossipFrame, HandleClaims, HandleRecord, HandshakeFrame, IceCandidateInit, IdentityKey, ManageCommand, ManageCommandParams, ManageError, ManageOk, ManageRequestFrame, ManageResponseFrame, MessageRef, NamespacedCapability, NamespacedDomainId, ObservedAddressFrame, OwnerNamedRoomPath, PeerAdvert, PeerIdentity, PingFrame, PrivateUseCapability, PrivateUseDomainId, ProcKill, ProcSignal, ProcSpawn, ProtocolVersion, PtyKill, PtyResize, PtySpawn, PtyWrite, RelayConnectFrame, RelayDataFrame, RelayInboundFrame, RelayOfferFrame, RevocationAnnounceFrame, RevocationClaims, RevocationEntry, RoomInvite, RoomJoin, RoomJoinOk, RoomLeave, RoomMember, RoomMembers, RoomMembersOk, RoomNotice, RoomNoticeClaims, RoomPath, RoomRead, RoomSend, StreamAckFrame, StreamDataFrame, StreamEndFrame, StreamSession, SyncPunchFrame, TokenClaims, WebrtcAnswer, WebrtcIceCandidate, WebrtcOffer, WireCandidate, candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomSendSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };
+import { $ as ProcSpawn, $n as roomNoticeSchema, $t as dataRequestFrameSchema, A as HandleClaims, An as procKillSchema, At as WebrtcAnswer, B as ManageResponseFrame, Bn as relayInboundFrameSchema, Bt as capabilityTokenSchema, C as DmRoomPath, Cn as observedAddressFrameSchema, Ct as RoomSend, D as Frame, Dn as pingFrameSchema, Dt as StreamSession, E as ExecSessionInfo, En as peerIdentitySchema, Et as StreamEndFrame, F as ManageCommand, Fn as ptyResizeSchema, Ft as candidatesFrameSchema, G as OwnerNamedRoomPath, Gn as roomInviteSchema, Gt as coreDomainNameSchema, H as NamespacedCapability, Hn as revocationAnnounceFrameSchema, Ht as closeFrameSchema, I as ManageCommandParams, In as ptySpawnSchema, It as capabilityGrantOkSchema, J as PingFrame, Jn as roomLeaveSchema, Jt as coseHeaderLabelSchema, K as PeerAdvert, Kn as roomJoinOkSchema, Kt as coseHeaderAlgSchema, L as ManageError, Ln as ptyWriteSchema, Lt as capabilityGrantSchema, M as HandshakeFrame, Mn as procSpawnSchema, Mt as WebrtcOffer, N as IceCandidateInit, Nn as protocolVersionSchema, Nt as WireCandidate, O as FrameVariant, On as privateUseCapabilitySchema, Ot as SyncPunchFrame, P as IdentityKey, Pn as ptyKillSchema, Pt as candidateKindSchema, Q as ProcSignal, Qn as roomNoticeClaimsSchema, Qt as dataHaveFrameSchema, R as ManageOk, Rn as relayConnectFrameSchema, Rt as capabilityRequestSchema, S as DeviceIdHex, Sn as namespacedDomainIdSchema, St as RoomRead, T as ExecList, Tn as peerAdvertSchema, Tt as StreamDataFrame, U as NamespacedDomainId, Un as revocationClaimsSchema, Ut as coordinatorFrameSchema, V as MessageRef, Vn as relayOfferFrameSchema, Vt as capabilityVerbSchema, W as ObservedAddressFrame, Wn as revocationEntrySchema, Wt as coreCapabilitySchema, X as PrivateUseDomainId, Xn as roomMembersOkSchema, Xt as coseTokenHeadersSchema, Y as PrivateUseCapability, Yn as roomMemberSchema, Yt as coseSign1Schema, Z as ProcKill, Zn as roomMembersSchema, Zt as dataEntriesFrameSchema, _ as CoseTokenHeaders, _n as manageOkSchema, _t as RoomMembers, a as CapabilityRequest, an as execSessionInfoSchema, ar as streamEndFrameSchema, at as RelayConnectFrame, b as DataRequestFrame, bn as messageRefSchema, bt as RoomNoticeClaims, c as CapabilityVerb, cn as gossipFrameSchema, cr as tokenClaimsSchema, ct as RelayOfferFrame, d as CoreCapability, dn as handshakeFrameSchema, dr as webrtcOfferSchema, dt as RevocationEntry, en as deviceIdHexSchema, er as roomPathSchema, et as ProtocolVersion, f as CoreDomainName, fn as iceCandidateInitSchema, fr as wireCandidateSchema, ft as RoomInvite, g as CoseSign1, gn as manageErrorSchema, gt as RoomMember, h as CoseHeaderLabel, hn as manageCommandSchema, ht as RoomLeave, i as CapabilityGrantOk, in as execListSchema, ir as streamDataFrameSchema, it as PtyWrite, j as HandleRecord, jn as procSignalSchema, jt as WebrtcIceCandidate, k as GossipFrame, kn as privateUseDomainIdSchema, kt as TokenClaims, l as CloseFrame, ln as handleClaimsSchema, lr as webrtcAnswerSchema, lt as RevocationAnnounceFrame, m as CoseHeaderKid, mn as manageCommandParamsSchema, mt as RoomJoinOk, n as CandidatesFrame, nn as dmRoomPathSchema, nr as roomSendSchema, nt as PtyResize, o as CapabilityScope, on as frameSchema, or as streamSessionSchema, ot as RelayDataFrame, p as CoseHeaderAlg, pn as identityKeySchema, pt as RoomJoin, q as PeerIdentity, qn as roomJoinSchema, qt as coseHeaderKidSchema, r as CapabilityGrant, rn as domainIdSchema, rr as streamAckFrameSchema, rt as PtySpawn, s as CapabilityToken, sn as frameVariantSchema, sr as syncPunchFrameSchema, st as RelayInboundFrame, t as CandidateKind, tn as deviceIdSchema, tr as roomReadSchema, tt as PtyKill, u as CoordinatorFrame, un as handleRecordSchema, ur as webrtcIceCandidateSchema, ut as RevocationClaims, v as DataEntriesFrame, vn as manageRequestFrameSchema, vt as RoomMembersOk, w as DomainId, wn as ownerNamedRoomPathSchema, wt as StreamAckFrame, x as DeviceId, xn as namespacedCapabilitySchema, xt as RoomPath, y as DataHaveFrame, yn as manageResponseFrameSchema, yt as RoomNotice, z as ManageRequestFrame, zn as relayDataFrameSchema, zt as capabilityScopeSchema } from "../protocol-Dhswk7YD.mjs";
+export { CandidateKind, CandidatesFrame, CapabilityGrant, CapabilityGrantOk, CapabilityRequest, CapabilityScope, CapabilityToken, CapabilityVerb, CloseFrame, CoordinatorFrame, CoreCapability, CoreDomainName, CoseHeaderAlg, CoseHeaderKid, CoseHeaderLabel, CoseSign1, CoseTokenHeaders, DataEntriesFrame, DataHaveFrame, DataRequestFrame, DeviceId, DeviceIdHex, DmRoomPath, DomainId, ExecList, ExecSessionInfo, Frame, FrameVariant, GossipFrame, HandleClaims, HandleRecord, HandshakeFrame, IceCandidateInit, IdentityKey, ManageCommand, ManageCommandParams, ManageError, ManageOk, ManageRequestFrame, ManageResponseFrame, MessageRef, NamespacedCapability, NamespacedDomainId, ObservedAddressFrame, OwnerNamedRoomPath, PeerAdvert, PeerIdentity, PingFrame, PrivateUseCapability, PrivateUseDomainId, ProcKill, ProcSignal, ProcSpawn, ProtocolVersion, PtyKill, PtyResize, PtySpawn, PtyWrite, RelayConnectFrame, RelayDataFrame, RelayInboundFrame, RelayOfferFrame, RevocationAnnounceFrame, RevocationClaims, RevocationEntry, RoomInvite, RoomJoin, RoomJoinOk, RoomLeave, RoomMember, RoomMembers, RoomMembersOk, RoomNotice, RoomNoticeClaims, RoomPath, RoomRead, RoomSend, StreamAckFrame, StreamDataFrame, StreamEndFrame, StreamSession, SyncPunchFrame, TokenClaims, WebrtcAnswer, WebrtcIceCandidate, WebrtcOffer, WireCandidate, candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityGrantSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomSendSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };

package/dist/generated/protocol.mjs

@@ -39,6 +39,7 @@ const manageCommandParamsSchema = z.lazy(() => z.union([
 	]),
 	z.object({}).catchall(z.unknown()),
 	z.lazy(() => capabilityRequestSchema),
+	z.lazy(() => capabilityGrantSchema),
 	z.union([
 		z.lazy(() => roomSendSchema),
 		z.lazy(() => roomReadSchema),
@@ -186,6 +187,10 @@ const capabilityGrantOkSchema = z.lazy(() => z.object({
 	"result": z.literal("ok"),
 	"granted-token": z.lazy(() => capabilityTokenSchema)
 }).catchall(z.unknown()));
+const capabilityGrantSchema = z.lazy(() => z.object({
+	"verb": z.literal("capability.grant"),
+	"granted-token": z.lazy(() => capabilityTokenSchema)
+}).catchall(z.unknown()));
 const revocationClaimsSchema = z.lazy(() => z.object({
 	"token-id": z.instanceof(Uint8Array),
 	"issuer": z.lazy(() => deviceIdSchema),
@@ -391,4 +396,4 @@ const iceCandidateInitSchema = z.lazy(() => z.object({
 	"username-fragment": z.string().optional()
 }));
 //#endregion
-export { candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomSendSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };
+export { candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityGrantSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomSendSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };

package/dist/{identity-D8iJZRZZ.d.mts → identity-B1hBV3YA.d.mts}

@@ -1,4 +1,4 @@
-import { N as IdentityKey, b as DeviceId } from "./protocol-MnxTzpRP.mjs";
+import { P as IdentityKey, x as DeviceId } from "./protocol-Dhswk7YD.mjs";
 //#region src/ports/identity.d.ts
 /**
  * Wraps the local node's own identity plus the signing/verification primitives capability-token handling needs -- never hardcoded to one crypto library's own API shape (Node's webcrypto, a WASM implementation, a hardware key, etc. can all satisfy this same contract).

package/dist/{identity-DkEe1465.d.cts → identity-BldV8xFj.d.cts}

@@ -1,4 +1,4 @@
-import { N as IdentityKey, b as DeviceId } from "./protocol-MnxTzpRP.cjs";
+import { P as IdentityKey, x as DeviceId } from "./protocol-Dhswk7YD.cjs";
 //#region src/ports/identity.d.ts
 /**
  * Wraps the local node's own identity plus the signing/verification primitives capability-token handling needs -- never hardcoded to one crypto library's own API shape (Node's webcrypto, a WASM implementation, a hardware key, etc. can all satisfy this same contract).

package/dist/ports/identity.d.cts

@@ -1,2 +1,2 @@
-import { t as IdentityPort } from "../identity-DkEe1465.cjs";
+import { t as IdentityPort } from "../identity-BldV8xFj.cjs";
 export { IdentityPort };

package/dist/ports/identity.d.mts

@@ -1,2 +1,2 @@
-import { t as IdentityPort } from "../identity-D8iJZRZZ.mjs";
+import { t as IdentityPort } from "../identity-B1hBV3YA.mjs";
 export { IdentityPort };

package/dist/ports/transport.d.cts

@@ -1,2 +1,2 @@
-import { n as Listener, r as Transport, t as Connection } from "../transport-Da7GP9ya.cjs";
+import { n as Listener, r as Transport, t as Connection } from "../transport-hEUxrdhT.cjs";
 export { Connection, Listener, Transport };

package/dist/ports/transport.d.mts

@@ -1,2 +1,2 @@
-import { n as Listener, r as Transport, t as Connection } from "../transport-ESMXRz3s.mjs";
+import { n as Listener, r as Transport, t as Connection } from "../transport-BNNdUBq-.mjs";
 export { Connection, Listener, Transport };

package/dist/{protocol-MnxTzpRP.d.cts → protocol-Dhswk7YD.d.cts}

@@ -75,6 +75,12 @@ declare const manageCommandParamsSchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodUni
   verb: z.ZodLiteral<"capability.request">;
   capability: z.ZodString;
   "valid-until": z.ZodOptional<z.ZodNumber>;
+}, z.core.$catchall<z.ZodUnknown>>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+  verb: z.ZodLiteral<"capability.grant">;
+  "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+    "1": z.ZodOptional<z.ZodNumber>;
+    "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+  }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
 }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodLazy<z.ZodLazy<z.ZodObject<{
   verb: z.ZodLiteral<"room.send">;
   "message-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
@@ -263,6 +269,12 @@ declare const frameVariantSchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodLazy<z.Zod
       verb: z.ZodLiteral<"capability.request">;
       capability: z.ZodString;
       "valid-until": z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      verb: z.ZodLiteral<"capability.grant">;
+      "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+        "1": z.ZodOptional<z.ZodNumber>;
+        "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+      }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
     }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodLazy<z.ZodLazy<z.ZodObject<{
       verb: z.ZodLiteral<"room.send">;
       "message-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
@@ -457,6 +469,12 @@ declare const frameSchema: z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodUnion<readonly [z.
       verb: z.ZodLiteral<"capability.request">;
       capability: z.ZodString;
       "valid-until": z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      verb: z.ZodLiteral<"capability.grant">;
+      "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+        "1": z.ZodOptional<z.ZodNumber>;
+        "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+      }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
     }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodLazy<z.ZodLazy<z.ZodObject<{
       verb: z.ZodLiteral<"room.send">;
       "message-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
@@ -622,6 +640,12 @@ declare const manageCommandSchema: z.ZodLazy<z.ZodObject<{
     verb: z.ZodLiteral<"capability.request">;
     capability: z.ZodString;
     "valid-until": z.ZodOptional<z.ZodNumber>;
+  }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+    verb: z.ZodLiteral<"capability.grant">;
+    "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      "1": z.ZodOptional<z.ZodNumber>;
+      "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+    }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
   }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodLazy<z.ZodLazy<z.ZodObject<{
     verb: z.ZodLiteral<"room.send">;
     "message-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
@@ -712,6 +736,12 @@ declare const manageRequestFrameSchema: z.ZodLazy<z.ZodObject<{
       verb: z.ZodLiteral<"capability.request">;
       capability: z.ZodString;
       "valid-until": z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      verb: z.ZodLiteral<"capability.grant">;
+      "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+        "1": z.ZodOptional<z.ZodNumber>;
+        "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+      }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
     }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodLazy<z.ZodLazy<z.ZodObject<{
       verb: z.ZodLiteral<"room.send">;
       "message-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
@@ -798,6 +828,13 @@ declare const capabilityGrantOkSchema: z.ZodLazy<z.ZodObject<{
     "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
   }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
 }, z.core.$catchall<z.ZodUnknown>>>;
+declare const capabilityGrantSchema: z.ZodLazy<z.ZodObject<{
+  verb: z.ZodLiteral<"capability.grant">;
+  "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+    "1": z.ZodOptional<z.ZodNumber>;
+    "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+  }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
+}, z.core.$catchall<z.ZodUnknown>>>;
 declare const revocationClaimsSchema: z.ZodLazy<z.ZodObject<{
   "token-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
   issuer: z.ZodLazy<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
@@ -1091,6 +1128,7 @@ type ManageError = z.infer<typeof manageErrorSchema>;
 type ManageResponseFrame = z.infer<typeof manageResponseFrameSchema>;
 type CapabilityRequest = z.infer<typeof capabilityRequestSchema>;
 type CapabilityGrantOk = z.infer<typeof capabilityGrantOkSchema>;
+type CapabilityGrant = z.infer<typeof capabilityGrantSchema>;
 type RevocationClaims = z.infer<typeof revocationClaimsSchema>;
 type RevocationEntry = z.infer<typeof revocationEntrySchema>;
 type RevocationAnnounceFrame = z.infer<typeof revocationAnnounceFrameSchema>;
@@ -1145,4 +1183,4 @@ type WebrtcAnswer = z.infer<typeof webrtcAnswerSchema>;
 type WebrtcIceCandidate = z.infer<typeof webrtcIceCandidateSchema>;
 type IceCandidateInit = z.infer<typeof iceCandidateInitSchema>;
 //#endregion
-export { ProtocolVersion as $, roomReadSchema as $n, deviceIdSchema as $t, HandleRecord as A, procSpawnSchema as An, WebrtcIceCandidate as At, MessageRef as B, revocationAnnounceFrameSchema as Bn, closeFrameSchema as Bt, DomainId as C, peerAdvertSchema as Cn, StreamAckFrame as Ct, FrameVariant as D, privateUseDomainIdSchema as Dn, SyncPunchFrame as Dt, Frame as E, privateUseCapabilitySchema as En, StreamSession as Et, ManageCommandParams as F, ptyWriteSchema as Fn, capabilityGrantOkSchema as Ft, PeerAdvert as G, roomJoinSchema as Gn, coseHeaderKidSchema as Gt, NamespacedDomainId as H, revocationEntrySchema as Hn, coreCapabilitySchema as Ht, ManageError as I, relayConnectFrameSchema as In, capabilityRequestSchema as It, PrivateUseCapability as J, roomMembersOkSchema as Jn, coseTokenHeadersSchema as Jt, PeerIdentity as K, roomLeaveSchema as Kn, coseHeaderLabelSchema as Kt, ManageOk as L, relayDataFrameSchema as Ln, capabilityScopeSchema as Lt, IceCandidateInit as M, ptyKillSchema as Mn, WireCandidate as Mt, IdentityKey as N, ptyResizeSchema as Nn, candidateKindSchema as Nt, GossipFrame as O, procKillSchema as On, TokenClaims as Ot, ManageCommand as P, ptySpawnSchema as Pn, candidatesFrameSchema as Pt, ProcSpawn as Q, roomPathSchema as Qn, deviceIdHexSchema as Qt, ManageRequestFrame as R, relayInboundFrameSchema as Rn, capabilityTokenSchema as Rt, DmRoomPath as S, ownerNamedRoomPathSchema as Sn, RoomSend as St, ExecSessionInfo as T, pingFrameSchema as Tn, StreamEndFrame as Tt, ObservedAddressFrame as U, roomInviteSchema as Un, coreDomainNameSchema as Ut, NamespacedCapability as V, revocationClaimsSchema as Vn, coordinatorFrameSchema as Vt, OwnerNamedRoomPath as W, roomJoinOkSchema as Wn, coseHeaderAlgSchema as Wt, ProcKill as X, roomNoticeClaimsSchema as Xn, dataHaveFrameSchema as Xt, PrivateUseDomainId as Y, roomMembersSchema as Yn, dataEntriesFrameSchema as Yt, ProcSignal as Z, roomNoticeSchema as Zn, dataRequestFrameSchema as Zt, DataEntriesFrame as _, manageResponseFrameSchema as _n, RoomMembersOk as _t, CapabilityScope as a, frameVariantSchema as an, syncPunchFrameSchema as ar, RelayDataFrame as at, DeviceId as b, namespacedDomainIdSchema as bn, RoomPath as bt, CloseFrame as c, handleRecordSchema as cn, webrtcIceCandidateSchema as cr, RevocationAnnounceFrame as ct, CoreDomainName as d, identityKeySchema as dn, RoomInvite as dt, dmRoomPathSchema as en, roomSendSchema as er, PtyKill as et, CoseHeaderAlg as f, manageCommandParamsSchema as fn, RoomJoin as ft, CoseTokenHeaders as g, manageRequestFrameSchema as gn, RoomMembers as gt, CoseSign1 as h, manageOkSchema as hn, RoomMember as ht, CapabilityRequest as i, frameSchema as in, streamSessionSchema as ir, RelayConnectFrame as it, HandshakeFrame as j, protocolVersionSchema as jn, WebrtcOffer as jt, HandleClaims as k, procSignalSchema as kn, WebrtcAnswer as kt, CoordinatorFrame as l, handshakeFrameSchema as ln, webrtcOfferSchema as lr, RevocationClaims as lt, CoseHeaderLabel as m, manageErrorSchema as mn, RoomLeave as mt, CandidatesFrame as n, execListSchema as nn, streamDataFrameSchema as nr, PtySpawn as nt, CapabilityToken as o, gossipFrameSchema as on, tokenClaimsSchema as or, RelayInboundFrame as ot, CoseHeaderKid as p, manageCommandSchema as pn, RoomJoinOk as pt, PingFrame as q, roomMemberSchema as qn, coseSign1Schema as qt, CapabilityGrantOk as r, execSessionInfoSchema as rn, streamEndFrameSchema as rr, PtyWrite as rt, CapabilityVerb as s, handleClaimsSchema as sn, webrtcAnswerSchema as sr, RelayOfferFrame as st, CandidateKind as t, domainIdSchema as tn, streamAckFrameSchema as tr, PtyResize as tt, CoreCapability as u, iceCandidateInitSchema as un, wireCandidateSchema as ur, RevocationEntry as ut, DataHaveFrame as v, messageRefSchema as vn, RoomNotice as vt, ExecList as w, peerIdentitySchema as wn, StreamDataFrame as wt, DeviceIdHex as x, observedAddressFrameSchema as xn, RoomRead as xt, DataRequestFrame as y, namespacedCapabilitySchema as yn, RoomNoticeClaims as yt, ManageResponseFrame as z, relayOfferFrameSchema as zn, capabilityVerbSchema as zt };
+export { ProcSpawn as $, roomNoticeSchema as $n, dataRequestFrameSchema as $t, HandleClaims as A, procKillSchema as An, WebrtcAnswer as At, ManageResponseFrame as B, relayInboundFrameSchema as Bn, capabilityTokenSchema as Bt, DmRoomPath as C, observedAddressFrameSchema as Cn, RoomSend as Ct, Frame as D, pingFrameSchema as Dn, StreamSession as Dt, ExecSessionInfo as E, peerIdentitySchema as En, StreamEndFrame as Et, ManageCommand as F, ptyResizeSchema as Fn, candidatesFrameSchema as Ft, OwnerNamedRoomPath as G, roomInviteSchema as Gn, coreDomainNameSchema as Gt, NamespacedCapability as H, revocationAnnounceFrameSchema as Hn, closeFrameSchema as Ht, ManageCommandParams as I, ptySpawnSchema as In, capabilityGrantOkSchema as It, PingFrame as J, roomLeaveSchema as Jn, coseHeaderLabelSchema as Jt, PeerAdvert as K, roomJoinOkSchema as Kn, coseHeaderAlgSchema as Kt, ManageError as L, ptyWriteSchema as Ln, capabilityGrantSchema as Lt, HandshakeFrame as M, procSpawnSchema as Mn, WebrtcOffer as Mt, IceCandidateInit as N, protocolVersionSchema as Nn, WireCandidate as Nt, FrameVariant as O, privateUseCapabilitySchema as On, SyncPunchFrame as Ot, IdentityKey as P, ptyKillSchema as Pn, candidateKindSchema as Pt, ProcSignal as Q, roomNoticeClaimsSchema as Qn, dataHaveFrameSchema as Qt, ManageOk as R, relayConnectFrameSchema as Rn, capabilityRequestSchema as Rt, DeviceIdHex as S, namespacedDomainIdSchema as Sn, RoomRead as St, ExecList as T, peerAdvertSchema as Tn, StreamDataFrame as Tt, NamespacedDomainId as U, revocationClaimsSchema as Un, coordinatorFrameSchema as Ut, MessageRef as V, relayOfferFrameSchema as Vn, capabilityVerbSchema as Vt, ObservedAddressFrame as W, revocationEntrySchema as Wn, coreCapabilitySchema as Wt, PrivateUseDomainId as X, roomMembersOkSchema as Xn, coseTokenHeadersSchema as Xt, PrivateUseCapability as Y, roomMemberSchema as Yn, coseSign1Schema as Yt, ProcKill as Z, roomMembersSchema as Zn, dataEntriesFrameSchema as Zt, CoseTokenHeaders as _, manageOkSchema as _n, RoomMembers as _t, CapabilityRequest as a, execSessionInfoSchema as an, streamEndFrameSchema as ar, RelayConnectFrame as at, DataRequestFrame as b, messageRefSchema as bn, RoomNoticeClaims as bt, CapabilityVerb as c, gossipFrameSchema as cn, tokenClaimsSchema as cr, RelayOfferFrame as ct, CoreCapability as d, handshakeFrameSchema as dn, webrtcOfferSchema as dr, RevocationEntry as dt, deviceIdHexSchema as en, roomPathSchema as er, ProtocolVersion as et, CoreDomainName as f, iceCandidateInitSchema as fn, wireCandidateSchema as fr, RoomInvite as ft, CoseSign1 as g, manageErrorSchema as gn, RoomMember as gt, CoseHeaderLabel as h, manageCommandSchema as hn, RoomLeave as ht, CapabilityGrantOk as i, execListSchema as in, streamDataFrameSchema as ir, PtyWrite as it, HandleRecord as j, procSignalSchema as jn, WebrtcIceCandidate as jt, GossipFrame as k, privateUseDomainIdSchema as kn, TokenClaims as kt, CloseFrame as l, handleClaimsSchema as ln, webrtcAnswerSchema as lr, RevocationAnnounceFrame as lt, CoseHeaderKid as m, manageCommandParamsSchema as mn, RoomJoinOk as mt, CandidatesFrame as n, dmRoomPathSchema as nn, roomSendSchema as nr, PtyResize as nt, CapabilityScope as o, frameSchema as on, streamSessionSchema as or, RelayDataFrame as ot, CoseHeaderAlg as p, identityKeySchema as pn, RoomJoin as pt, PeerIdentity as q, roomJoinSchema as qn, coseHeaderKidSchema as qt, CapabilityGrant as r, domainIdSchema as rn, streamAckFrameSchema as rr, PtySpawn as rt, CapabilityToken as s, frameVariantSchema as sn, syncPunchFrameSchema as sr, RelayInboundFrame as st, CandidateKind as t, deviceIdSchema as tn, roomReadSchema as tr, PtyKill as tt, CoordinatorFrame as u, handleRecordSchema as un, webrtcIceCandidateSchema as ur, RevocationClaims as ut, DataEntriesFrame as v, manageRequestFrameSchema as vn, RoomMembersOk as vt, DomainId as w, ownerNamedRoomPathSchema as wn, StreamAckFrame as wt, DeviceId as x, namespacedCapabilitySchema as xn, RoomPath as xt, DataHaveFrame as y, manageResponseFrameSchema as yn, RoomNotice as yt, ManageRequestFrame as z, relayDataFrameSchema as zn, capabilityScopeSchema as zt };

package/dist/{protocol-MnxTzpRP.d.mts → protocol-Dhswk7YD.d.mts}

@@ -75,6 +75,12 @@ declare const manageCommandParamsSchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodUni
   verb: z.ZodLiteral<"capability.request">;
   capability: z.ZodString;
   "valid-until": z.ZodOptional<z.ZodNumber>;
+}, z.core.$catchall<z.ZodUnknown>>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+  verb: z.ZodLiteral<"capability.grant">;
+  "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+    "1": z.ZodOptional<z.ZodNumber>;
+    "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+  }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
 }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodLazy<z.ZodLazy<z.ZodObject<{
   verb: z.ZodLiteral<"room.send">;
   "message-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
@@ -263,6 +269,12 @@ declare const frameVariantSchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodLazy<z.Zod
       verb: z.ZodLiteral<"capability.request">;
       capability: z.ZodString;
       "valid-until": z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      verb: z.ZodLiteral<"capability.grant">;
+      "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+        "1": z.ZodOptional<z.ZodNumber>;
+        "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+      }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
     }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodLazy<z.ZodLazy<z.ZodObject<{
       verb: z.ZodLiteral<"room.send">;
       "message-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
@@ -457,6 +469,12 @@ declare const frameSchema: z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodUnion<readonly [z.
       verb: z.ZodLiteral<"capability.request">;
       capability: z.ZodString;
       "valid-until": z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      verb: z.ZodLiteral<"capability.grant">;
+      "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+        "1": z.ZodOptional<z.ZodNumber>;
+        "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+      }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
     }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodLazy<z.ZodLazy<z.ZodObject<{
       verb: z.ZodLiteral<"room.send">;
       "message-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
@@ -622,6 +640,12 @@ declare const manageCommandSchema: z.ZodLazy<z.ZodObject<{
     verb: z.ZodLiteral<"capability.request">;
     capability: z.ZodString;
     "valid-until": z.ZodOptional<z.ZodNumber>;
+  }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+    verb: z.ZodLiteral<"capability.grant">;
+    "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      "1": z.ZodOptional<z.ZodNumber>;
+      "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+    }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
   }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodLazy<z.ZodLazy<z.ZodObject<{
     verb: z.ZodLiteral<"room.send">;
     "message-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
@@ -712,6 +736,12 @@ declare const manageRequestFrameSchema: z.ZodLazy<z.ZodObject<{
       verb: z.ZodLiteral<"capability.request">;
       capability: z.ZodString;
       "valid-until": z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      verb: z.ZodLiteral<"capability.grant">;
+      "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+        "1": z.ZodOptional<z.ZodNumber>;
+        "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+      }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
     }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodLazy<z.ZodLazy<z.ZodObject<{
       verb: z.ZodLiteral<"room.send">;
       "message-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
@@ -798,6 +828,13 @@ declare const capabilityGrantOkSchema: z.ZodLazy<z.ZodObject<{
     "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
   }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
 }, z.core.$catchall<z.ZodUnknown>>>;
+declare const capabilityGrantSchema: z.ZodLazy<z.ZodObject<{
+  verb: z.ZodLiteral<"capability.grant">;
+  "granted-token": z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+    "1": z.ZodOptional<z.ZodNumber>;
+    "4": z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+  }, z.core.$catchall<z.ZodUnknown>>>>, z.ZodUnion<readonly [z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodNull]>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>], null>>>>>;
+}, z.core.$catchall<z.ZodUnknown>>>;
 declare const revocationClaimsSchema: z.ZodLazy<z.ZodObject<{
   "token-id": z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
   issuer: z.ZodLazy<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
@@ -1091,6 +1128,7 @@ type ManageError = z.infer<typeof manageErrorSchema>;
 type ManageResponseFrame = z.infer<typeof manageResponseFrameSchema>;
 type CapabilityRequest = z.infer<typeof capabilityRequestSchema>;
 type CapabilityGrantOk = z.infer<typeof capabilityGrantOkSchema>;
+type CapabilityGrant = z.infer<typeof capabilityGrantSchema>;
 type RevocationClaims = z.infer<typeof revocationClaimsSchema>;
 type RevocationEntry = z.infer<typeof revocationEntrySchema>;
 type RevocationAnnounceFrame = z.infer<typeof revocationAnnounceFrameSchema>;
@@ -1145,4 +1183,4 @@ type WebrtcAnswer = z.infer<typeof webrtcAnswerSchema>;
 type WebrtcIceCandidate = z.infer<typeof webrtcIceCandidateSchema>;
 type IceCandidateInit = z.infer<typeof iceCandidateInitSchema>;
 //#endregion
-export { ProtocolVersion as $, roomReadSchema as $n, deviceIdSchema as $t, HandleRecord as A, procSpawnSchema as An, WebrtcIceCandidate as At, MessageRef as B, revocationAnnounceFrameSchema as Bn, closeFrameSchema as Bt, DomainId as C, peerAdvertSchema as Cn, StreamAckFrame as Ct, FrameVariant as D, privateUseDomainIdSchema as Dn, SyncPunchFrame as Dt, Frame as E, privateUseCapabilitySchema as En, StreamSession as Et, ManageCommandParams as F, ptyWriteSchema as Fn, capabilityGrantOkSchema as Ft, PeerAdvert as G, roomJoinSchema as Gn, coseHeaderKidSchema as Gt, NamespacedDomainId as H, revocationEntrySchema as Hn, coreCapabilitySchema as Ht, ManageError as I, relayConnectFrameSchema as In, capabilityRequestSchema as It, PrivateUseCapability as J, roomMembersOkSchema as Jn, coseTokenHeadersSchema as Jt, PeerIdentity as K, roomLeaveSchema as Kn, coseHeaderLabelSchema as Kt, ManageOk as L, relayDataFrameSchema as Ln, capabilityScopeSchema as Lt, IceCandidateInit as M, ptyKillSchema as Mn, WireCandidate as Mt, IdentityKey as N, ptyResizeSchema as Nn, candidateKindSchema as Nt, GossipFrame as O, procKillSchema as On, TokenClaims as Ot, ManageCommand as P, ptySpawnSchema as Pn, candidatesFrameSchema as Pt, ProcSpawn as Q, roomPathSchema as Qn, deviceIdHexSchema as Qt, ManageRequestFrame as R, relayInboundFrameSchema as Rn, capabilityTokenSchema as Rt, DmRoomPath as S, ownerNamedRoomPathSchema as Sn, RoomSend as St, ExecSessionInfo as T, pingFrameSchema as Tn, StreamEndFrame as Tt, ObservedAddressFrame as U, roomInviteSchema as Un, coreDomainNameSchema as Ut, NamespacedCapability as V, revocationClaimsSchema as Vn, coordinatorFrameSchema as Vt, OwnerNamedRoomPath as W, roomJoinOkSchema as Wn, coseHeaderAlgSchema as Wt, ProcKill as X, roomNoticeClaimsSchema as Xn, dataHaveFrameSchema as Xt, PrivateUseDomainId as Y, roomMembersSchema as Yn, dataEntriesFrameSchema as Yt, ProcSignal as Z, roomNoticeSchema as Zn, dataRequestFrameSchema as Zt, DataEntriesFrame as _, manageResponseFrameSchema as _n, RoomMembersOk as _t, CapabilityScope as a, frameVariantSchema as an, syncPunchFrameSchema as ar, RelayDataFrame as at, DeviceId as b, namespacedDomainIdSchema as bn, RoomPath as bt, CloseFrame as c, handleRecordSchema as cn, webrtcIceCandidateSchema as cr, RevocationAnnounceFrame as ct, CoreDomainName as d, identityKeySchema as dn, RoomInvite as dt, dmRoomPathSchema as en, roomSendSchema as er, PtyKill as et, CoseHeaderAlg as f, manageCommandParamsSchema as fn, RoomJoin as ft, CoseTokenHeaders as g, manageRequestFrameSchema as gn, RoomMembers as gt, CoseSign1 as h, manageOkSchema as hn, RoomMember as ht, CapabilityRequest as i, frameSchema as in, streamSessionSchema as ir, RelayConnectFrame as it, HandshakeFrame as j, protocolVersionSchema as jn, WebrtcOffer as jt, HandleClaims as k, procSignalSchema as kn, WebrtcAnswer as kt, CoordinatorFrame as l, handshakeFrameSchema as ln, webrtcOfferSchema as lr, RevocationClaims as lt, CoseHeaderLabel as m, manageErrorSchema as mn, RoomLeave as mt, CandidatesFrame as n, execListSchema as nn, streamDataFrameSchema as nr, PtySpawn as nt, CapabilityToken as o, gossipFrameSchema as on, tokenClaimsSchema as or, RelayInboundFrame as ot, CoseHeaderKid as p, manageCommandSchema as pn, RoomJoinOk as pt, PingFrame as q, roomMemberSchema as qn, coseSign1Schema as qt, CapabilityGrantOk as r, execSessionInfoSchema as rn, streamEndFrameSchema as rr, PtyWrite as rt, CapabilityVerb as s, handleClaimsSchema as sn, webrtcAnswerSchema as sr, RelayOfferFrame as st, CandidateKind as t, domainIdSchema as tn, streamAckFrameSchema as tr, PtyResize as tt, CoreCapability as u, iceCandidateInitSchema as un, wireCandidateSchema as ur, RevocationEntry as ut, DataHaveFrame as v, messageRefSchema as vn, RoomNotice as vt, ExecList as w, peerIdentitySchema as wn, StreamDataFrame as wt, DeviceIdHex as x, observedAddressFrameSchema as xn, RoomRead as xt, DataRequestFrame as y, namespacedCapabilitySchema as yn, RoomNoticeClaims as yt, ManageResponseFrame as z, relayOfferFrameSchema as zn, capabilityVerbSchema as zt };
+export { ProcSpawn as $, roomNoticeSchema as $n, dataRequestFrameSchema as $t, HandleClaims as A, procKillSchema as An, WebrtcAnswer as At, ManageResponseFrame as B, relayInboundFrameSchema as Bn, capabilityTokenSchema as Bt, DmRoomPath as C, observedAddressFrameSchema as Cn, RoomSend as Ct, Frame as D, pingFrameSchema as Dn, StreamSession as Dt, ExecSessionInfo as E, peerIdentitySchema as En, StreamEndFrame as Et, ManageCommand as F, ptyResizeSchema as Fn, candidatesFrameSchema as Ft, OwnerNamedRoomPath as G, roomInviteSchema as Gn, coreDomainNameSchema as Gt, NamespacedCapability as H, revocationAnnounceFrameSchema as Hn, closeFrameSchema as Ht, ManageCommandParams as I, ptySpawnSchema as In, capabilityGrantOkSchema as It, PingFrame as J, roomLeaveSchema as Jn, coseHeaderLabelSchema as Jt, PeerAdvert as K, roomJoinOkSchema as Kn, coseHeaderAlgSchema as Kt, ManageError as L, ptyWriteSchema as Ln, capabilityGrantSchema as Lt, HandshakeFrame as M, procSpawnSchema as Mn, WebrtcOffer as Mt, IceCandidateInit as N, protocolVersionSchema as Nn, WireCandidate as Nt, FrameVariant as O, privateUseCapabilitySchema as On, SyncPunchFrame as Ot, IdentityKey as P, ptyKillSchema as Pn, candidateKindSchema as Pt, ProcSignal as Q, roomNoticeClaimsSchema as Qn, dataHaveFrameSchema as Qt, ManageOk as R, relayConnectFrameSchema as Rn, capabilityRequestSchema as Rt, DeviceIdHex as S, namespacedDomainIdSchema as Sn, RoomRead as St, ExecList as T, peerAdvertSchema as Tn, StreamDataFrame as Tt, NamespacedDomainId as U, revocationClaimsSchema as Un, coordinatorFrameSchema as Ut, MessageRef as V, relayOfferFrameSchema as Vn, capabilityVerbSchema as Vt, ObservedAddressFrame as W, revocationEntrySchema as Wn, coreCapabilitySchema as Wt, PrivateUseDomainId as X, roomMembersOkSchema as Xn, coseTokenHeadersSchema as Xt, PrivateUseCapability as Y, roomMemberSchema as Yn, coseSign1Schema as Yt, ProcKill as Z, roomMembersSchema as Zn, dataEntriesFrameSchema as Zt, CoseTokenHeaders as _, manageOkSchema as _n, RoomMembers as _t, CapabilityRequest as a, execSessionInfoSchema as an, streamEndFrameSchema as ar, RelayConnectFrame as at, DataRequestFrame as b, messageRefSchema as bn, RoomNoticeClaims as bt, CapabilityVerb as c, gossipFrameSchema as cn, tokenClaimsSchema as cr, RelayOfferFrame as ct, CoreCapability as d, handshakeFrameSchema as dn, webrtcOfferSchema as dr, RevocationEntry as dt, deviceIdHexSchema as en, roomPathSchema as er, ProtocolVersion as et, CoreDomainName as f, iceCandidateInitSchema as fn, wireCandidateSchema as fr, RoomInvite as ft, CoseSign1 as g, manageErrorSchema as gn, RoomMember as gt, CoseHeaderLabel as h, manageCommandSchema as hn, RoomLeave as ht, CapabilityGrantOk as i, execListSchema as in, streamDataFrameSchema as ir, PtyWrite as it, HandleRecord as j, procSignalSchema as jn, WebrtcIceCandidate as jt, GossipFrame as k, privateUseDomainIdSchema as kn, TokenClaims as kt, CloseFrame as l, handleClaimsSchema as ln, webrtcAnswerSchema as lr, RevocationAnnounceFrame as lt, CoseHeaderKid as m, manageCommandParamsSchema as mn, RoomJoinOk as mt, CandidatesFrame as n, dmRoomPathSchema as nn, roomSendSchema as nr, PtyResize as nt, CapabilityScope as o, frameSchema as on, streamSessionSchema as or, RelayDataFrame as ot, CoseHeaderAlg as p, identityKeySchema as pn, RoomJoin as pt, PeerIdentity as q, roomJoinSchema as qn, coseHeaderKidSchema as qt, CapabilityGrant as r, domainIdSchema as rn, streamAckFrameSchema as rr, PtySpawn as rt, CapabilityToken as s, frameVariantSchema as sn, syncPunchFrameSchema as sr, RelayInboundFrame as st, CandidateKind as t, deviceIdSchema as tn, roomReadSchema as tr, PtyKill as tt, CoordinatorFrame as u, handleRecordSchema as un, webrtcIceCandidateSchema as ur, RevocationClaims as ut, DataEntriesFrame as v, manageRequestFrameSchema as vn, RoomMembersOk as vt, DomainId as w, ownerNamedRoomPathSchema as wn, StreamAckFrame as wt, DeviceId as x, namespacedCapabilitySchema as xn, RoomPath as xt, DataHaveFrame as y, manageResponseFrameSchema as yn, RoomNotice as yt, ManageRequestFrame as z, relayDataFrameSchema as zn, capabilityScopeSchema as zt };

package/dist/{transport-Da7GP9ya.d.cts → transport-BNNdUBq-.d.mts}

@@ -1,4 +1,4 @@
-import { E as Frame, b as DeviceId } from "./protocol-MnxTzpRP.cjs";
+import { D as Frame, x as DeviceId } from "./protocol-Dhswk7YD.mjs";
 //#region src/ports/transport.d.ts
 /**
  * An async, serialisable-data contract for exchanging frame values over some connection -- deliberately without baking in any specific transport's own primitives (no raw socket types, no WebSocket-specific options), so a TCP adapter, a WebSocket adapter, or an in-memory adapter for tests can all satisfy it.

package/dist/{transport-ESMXRz3s.d.mts → transport-hEUxrdhT.d.cts}

@@ -1,4 +1,4 @@
-import { E as Frame, b as DeviceId } from "./protocol-MnxTzpRP.mjs";
+import { D as Frame, x as DeviceId } from "./protocol-Dhswk7YD.cjs";
 //#region src/ports/transport.d.ts
 /**
  * An async, serialisable-data contract for exchanging frame values over some connection -- deliberately without baking in any specific transport's own primitives (no raw socket types, no WebSocket-specific options), so a TCP adapter, a WebSocket adapter, or an in-memory adapter for tests can all satisfy it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wire-mesh-core",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "type": "module",
   "packageManager": "pnpm@12.4.1+sha512.2e81e399d73fe8390dab25e06aa788ab7a5908248d2f5a370f82b481147a6a7a367bf8048f9a6fdb6460f21a66f0542dedb8b94ca2c8723596741920b1656d4c",
   "repository": {
@@ -85,6 +85,10 @@
       "import": "./dist/adapters/tls-transport.mjs",
       "require": "./dist/adapters/tls-transport.cjs"
     },
+    "./domain/capability-grant": {
+      "import": "./dist/domain/capability-grant.mjs",
+      "require": "./dist/domain/capability-grant.cjs"
+    },
     "./domain/capability-request": {
       "import": "./dist/domain/capability-request.mjs",
       "require": "./dist/domain/capability-request.cjs"