permdock 0.4.0 → 0.5.0

package/dist/request-schema-CMreVuFM.js

@@ -0,0 +1,148 @@
+//#region src/approvals/request-schema.ts
+/** An RFC 3339 instant as `Temporal.Instant` prints it; pg_jsonschema asserts no `format`. */
+const INSTANT = String.raw`^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$`;
+const STRINGS = {
+	type: "array",
+	items: { type: "string" }
+};
+/**
+* `schemas/approval-request-v1.json`: the `ApprovalRequest` an approval store
+* holds. Self-contained (`$defs`, no remote `$ref`) so `rls.jsonSchema` can
+* inline it into a pg_jsonschema check constraint.
+*/
+const APPROVAL_REQUEST_SCHEMA = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://permdock.com/schemas/approval-request-v1.json",
+	title: "PermDock approval request",
+	description: "An ApprovalRequest as an ApprovalStore holds it, wire format v1. Unknown properties are allowed so a v1 minor release can add one.",
+	type: "object",
+	required: [
+		"v",
+		"id",
+		"token",
+		"permission",
+		"scope",
+		"resource",
+		"subject",
+		"detail",
+		"createdAt",
+		"expiresAt",
+		"status"
+	],
+	properties: {
+		v: { const: 1 },
+		id: {
+			type: "string",
+			minLength: 1
+		},
+		token: {
+			type: "string",
+			minLength: 1
+		},
+		permission: {
+			type: "string",
+			minLength: 1
+		},
+		scope: { type: "string" },
+		resource: {
+			type: "object",
+			required: ["type"],
+			properties: {
+				type: { type: "string" },
+				id: { type: "string" }
+			}
+		},
+		subject: { $ref: "#/$defs/subject" },
+		membership: {
+			type: "object",
+			required: ["roles"],
+			properties: { roles: STRINGS }
+		},
+		approvers: { type: "object" },
+		detail: { type: "string" },
+		adapter: { type: "string" },
+		createdAt: { $ref: "#/$defs/instant" },
+		expiresAt: { $ref: "#/$defs/instant" },
+		status: { enum: [
+			"pending",
+			"approved",
+			"rejected",
+			"expired"
+		] },
+		approvals: {
+			type: "array",
+			items: { $ref: "#/$defs/signature" }
+		},
+		resolvedAt: { $ref: "#/$defs/instant" },
+		resolvedBy: { type: "string" },
+		vouched: { type: "string" },
+		note: { type: "string" },
+		consumedAt: { $ref: "#/$defs/instant" },
+		x: {
+			type: "object",
+			description: "The application's own data, set when the request opens: plain JSON, never read by a decision."
+		}
+	},
+	$defs: {
+		instant: {
+			type: "string",
+			format: "date-time",
+			pattern: INSTANT
+		},
+		subject: {
+			type: "object",
+			required: ["principal"],
+			properties: {
+				principal: { anyOf: [{ type: "null" }, {
+					type: "object",
+					required: ["id", "roles"],
+					properties: {
+						id: { type: "string" },
+						roles: STRINGS,
+						tenant: { type: "string" }
+					}
+				}] },
+				actor: {
+					type: "object",
+					required: ["id", "kind"],
+					properties: {
+						id: { type: "string" },
+						kind: { type: "string" }
+					}
+				},
+				session: { type: "string" },
+				delegation: {
+					type: "object",
+					properties: {
+						scope: { type: "string" },
+						authorization_details: {
+							type: "array",
+							items: {
+								type: "object",
+								required: ["type"],
+								properties: { type: { type: "string" } }
+							}
+						}
+					}
+				}
+			}
+		},
+		signature: {
+			type: "object",
+			required: ["by", "at"],
+			properties: {
+				by: { type: "string" },
+				at: { $ref: "#/$defs/instant" },
+				stage: {
+					type: "integer",
+					minimum: 0
+				},
+				vouched: { type: "string" },
+				onBehalfOf: { type: "string" },
+				delegation: { type: "string" }
+			}
+		}
+	}
+};
+//#endregion
+export { APPROVAL_REQUEST_SCHEMA as t };

package/dist/resend/index.d.ts

@@ -0,0 +1,126 @@
+import { q as DecisionSink } from "../policy-types-DzwivBgR.js";
+import { n as ApprovalUrl, t as ApprovalPrompt } from "../approval-prompt-Djo_PyZc.js";
+import { d as EmailTransport, o as DeliveryResult, u as EmailMessage } from "../types-DX0LaKTb.js";
+import { l as ReplayStore } from "../types-DiQjupG2.js";
+//#region src/resend/approval-email.d.ts
+type ApprovalEmailOptions = {
+  /** The app's approval page: a base the request id is appended to, or a function of the prompt. Must be https. */
+  readonly approvalUrl: ApprovalUrl;
+  /** The product name in the footer line. */
+  readonly product?: string;
+};
+/**
+ * The default approval prompt email: an `approval`-category message whose
+ * one link opens the app's approval page for the request. It carries no
+ * approve or reject link; the signed-in approver decides on that page.
+ * Throws a `TypeError` for an approval page that is not https. Replace it
+ * with a React Email template by building the same `EmailMessage`.
+ */
+export declare function approvalEmail(prompt: ApprovalPrompt, options: ApprovalEmailOptions): EmailMessage;
+//#endregion
+//#region src/resend/transport.d.ts
+/** One email as `resend.emails.send` and `resend.batch.send` take it. */
+type ResendEmailPayload = {
+  readonly from: string;
+  readonly to: string[];
+  readonly subject: string;
+  readonly text: string;
+  readonly html?: string;
+  readonly replyTo?: string;
+  readonly headers?: Record<string, string>;
+  readonly tags?: {
+    readonly name: string;
+    readonly value: string;
+  }[];
+};
+type ResendError = {
+  readonly name: string;
+  readonly message: string;
+  readonly statusCode: number | null;
+};
+type ResendResult<T> = {
+  readonly data: T;
+  readonly error: null;
+} | {
+  readonly data: null;
+  readonly error: ResendError;
+};
+/** The part of a `Resend` client the transport calls; a `new Resend(key)` fits. */
+type ResendClient = {
+  readonly emails: {
+    send(payload: ResendEmailPayload, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<ResendResult<{
+      readonly id: string;
+    }>>;
+  };
+  readonly batch?: {
+    send(payloads: ResendEmailPayload[], options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<ResendResult<{
+      readonly data: readonly {
+        readonly id: string;
+      }[];
+    }>>;
+  };
+};
+type ResendTransportOptions = {
+  /** The `from` of an email whose message and router set none. */
+  readonly from?: string;
+  /** The `replyTo` of an email whose message sets none. */
+  readonly replyTo?: string;
+  /** Tags added to every email; names and values are ASCII letters, digits, `_` and `-`. */
+  readonly tags?: Readonly<Record<string, string>>;
+};
+/**
+ * The failure a Resend error name means. Rate limits, quotas and server
+ * errors are retryable with the same idempotency key; a key, sender or
+ * validation error is final. An unknown name is retryable only for a 5xx or
+ * a missing status.
+ */
+export declare function resendFailure(error: ResendError): DeliveryResult;
+/**
+ * Sends the email channel of `permdock/delivery` through Resend. The
+ * idempotency key is Resend's `idempotencyKey`. The delivery id, key and
+ * category travel as tags, so `resendWebhook` can join provider events to
+ * the delivery. Two or more recipients go out through `batch.send`, up to
+ * 100 per call. Throws a `TypeError` for a tag outside Resend's charset.
+ */
+export declare function resendTransport(resend: ResendClient, options?: ResendTransportOptions): EmailTransport;
+//#endregion
+//#region src/resend/webhook.d.ts
+/** The part of a `Resend` client the webhook calls; a `new Resend(key)` fits. */
+type ResendWebhookClient = {
+  readonly webhooks: {
+    verify(input: {
+      readonly payload: string;
+      readonly headers: {
+        readonly id: string;
+        readonly timestamp: string;
+        readonly signature: string;
+      };
+      readonly webhookSecret: string;
+    }): unknown;
+  };
+};
+type ResendWebhookOptions = {
+  readonly resend: ResendWebhookClient;
+  /** The endpoint's signing secret, `whsec_…`. */
+  readonly secret: string;
+  readonly sink: DecisionSink;
+  /** Claims each message id, so a redelivered message writes no second event. */
+  readonly replay: ReplayStore;
+  /** The event `source`; defaults to `permdock`. */
+  readonly source?: string;
+};
+/**
+ * A fetch handler for Resend webhooks. It verifies the Standard Webhooks
+ * signature through `resend.webhooks.verify` (the `svix-*` and `webhook-*`
+ * header names both work), claims the message id, and writes one delivery
+ * event for `email.delivered`, `email.bounced`, `email.complained`,
+ * `email.failed` and `email.suppressed`. A bad signature is a `401`; a sink
+ * failure releases the claim and answers `503`, so Resend retries.
+ */
+export declare function resendWebhook(options: ResendWebhookOptions): (request: Request) => Promise<Response>;
+//#endregion
+export type { ApprovalEmailOptions, ResendClient, ResendEmailPayload, ResendError, ResendResult, ResendTransportOptions, ResendWebhookClient, ResendWebhookOptions };

package/dist/resend/index.js

@@ -0,0 +1,379 @@
+import { t as compact } from "../compact-CAf557ZB.js";
+import { a as ownRecord } from "../paths-DXSHAMIa.js";
+import { o as statusProblem } from "../problem-details-cn5X30gZ.js";
+import { l as isRfc3339, p as nowSeconds } from "../time-DkWjdL98.js";
+import { n as sha256, t as bytesToBase64Url } from "../sha256-D9ihqmvd.js";
+import { t as deliveryEvent } from "../delivery-event-xX4obB8F.js";
+import { n as readBodyText } from "../body-text-QcXok_SI.js";
+import { a as methodNotAllowed, c as problemResponse } from "../problem-CTviyH5L.js";
+import { t as bodyTooLarge } from "../body-CH5of8Ne.js";
+import { n as approvalUrlFor } from "../approval-prompt-Dg5LeAcT.js";
+import { i as isDeliveryTarget } from "../target-Bw37TFNA.js";
+//#region src/resend/approval-email.ts
+const HTML_ESCAPES = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+function escapeHtml(value) {
+	return value.replaceAll(/[&<>"']/gu, (char) => HTML_ESCAPES[char] ?? char);
+}
+function oneLine(value) {
+	return value.replaceAll(/\s+/gu, " ").trim();
+}
+function requesterLine(prompt) {
+	const principal = prompt.requester.principal?.id ?? "an anonymous caller";
+	const actor = prompt.requester.actor;
+	return actor === void 0 ? `Requested by ${principal}` : `Requested by ${principal} through ${actor.kind} ${actor.id}`;
+}
+/**
+* The default approval prompt email: an `approval`-category message whose
+* one link opens the app's approval page for the request. It carries no
+* approve or reject link; the signed-in approver decides on that page.
+* Throws a `TypeError` for an approval page that is not https. Replace it
+* with a React Email template by building the same `EmailMessage`.
+*/
+function approvalEmail(prompt, options) {
+	const url = approvalUrlFor(prompt, options.approvalUrl);
+	const title = oneLine(prompt.operation?.title ?? prompt.detail);
+	const resource = prompt.resource.id === void 0 ? prompt.resource.type : `${prompt.resource.type} ${prompt.resource.id}`;
+	const lines = [
+		prompt.detail,
+		"",
+		`${requesterLine(prompt)}.`,
+		`Permission: ${prompt.permission} on ${resource}`,
+		...prompt.operation?.risk === void 0 ? [] : [`Risk: ${prompt.operation.risk}`],
+		`Expires ${prompt.expiresAt}`,
+		"",
+		`Review the request: ${url}`,
+		"",
+		`This link opens the approval page. Nothing is approved until you decide there${options.product === void 0 ? "" : ` in ${options.product}`}.`
+	];
+	const facts = lines.slice(2, lines.indexOf("", 2)).map((line) => `<li>${escapeHtml(line)}</li>`).join("");
+	const html = [
+		`<p>${escapeHtml(prompt.detail)}</p>`,
+		`<ul>${facts}</ul>`,
+		`<p><a href="${escapeHtml(url)}">Review the request</a></p>`,
+		`<p>${escapeHtml(lines.at(-1) ?? "")}</p>`
+	].join("\n");
+	return Object.freeze({
+		subject: `Approval needed: ${title}`,
+		text: lines.join("\n"),
+		html,
+		category: "approval"
+	});
+}
+//#endregion
+//#region src/resend/transport.ts
+/** Resend's tag charset, at most 256 characters. */
+const TAG = /^[A-Za-z0-9_-]{1,256}$/u;
+const DELIVERY_TAG = "permdock_delivery";
+const KEY_TAG = "permdock_key";
+const CATEGORY_TAG = "permdock_category";
+const RESERVED_TAGS = /* @__PURE__ */ new Set([
+	DELIVERY_TAG,
+	KEY_TAG,
+	CATEGORY_TAG
+]);
+const RETRYABLE = {
+	rate_limit_exceeded: "rate-limited",
+	daily_quota_exceeded: "quota-exceeded",
+	monthly_quota_exceeded: "quota-exceeded",
+	concurrent_idempotent_requests: "unavailable",
+	internal_server_error: "unavailable",
+	application_error: "unavailable"
+};
+const FINAL = {
+	invalid_api_key: "unauthorized",
+	missing_api_key: "unauthorized",
+	restricted_api_key: "unauthorized",
+	invalid_access: "unauthorized",
+	invalid_from_address: "invalid-message",
+	invalid_attachment: "invalid-message",
+	validation_error: "rejected"
+};
+/**
+* The failure a Resend error name means. Rate limits, quotas and server
+* errors are retryable with the same idempotency key; a key, sender or
+* validation error is final. An unknown name is retryable only for a 5xx or
+* a missing status.
+*/
+function resendFailure(error) {
+	const name = error.name;
+	const retryable = Object.hasOwn(RETRYABLE, name) ? RETRYABLE[name] : void 0;
+	if (retryable !== void 0) return {
+		status: "failed",
+		cause: retryable,
+		retryable: true,
+		reason: name
+	};
+	const final = Object.hasOwn(FINAL, name) ? FINAL[name] : void 0;
+	if (final !== void 0) return {
+		status: "failed",
+		cause: final,
+		retryable: false,
+		reason: name
+	};
+	const status = error.statusCode;
+	return status === null || status >= 500 ? {
+		status: "failed",
+		cause: "unavailable",
+		retryable: true,
+		reason: name
+	} : {
+		status: "failed",
+		cause: "rejected",
+		retryable: false,
+		reason: name
+	};
+}
+const UNAVAILABLE = Object.freeze({
+	status: "failed",
+	cause: "unavailable",
+	retryable: true,
+	reason: "request failed"
+});
+function checkTags(tags) {
+	return Object.entries(tags).map(([name, value]) => {
+		if (!TAG.test(name) || !TAG.test(value) || RESERVED_TAGS.has(name)) throw new TypeError(`PermDock: Resend tag ${JSON.stringify(name)} is reserved or outside [A-Za-z0-9_-]`);
+		return {
+			name,
+			value
+		};
+	});
+}
+const REFUSED = Object.freeze({
+	status: "failed",
+	cause: "invalid-recipient",
+	retryable: false
+});
+async function sendBatch(resend, items, payloadOf) {
+	const results = items.map(() => REFUSED);
+	const valid = items.flatMap((item, index) => isDeliveryTarget(item.target, "email") ? [index] : []);
+	if (valid.length === 0 || resend.batch === void 0) return results;
+	const key = `pdb_${bytesToBase64Url(sha256(JSON.stringify(valid.map((index) => items[index]?.options.idempotencyKey))))}`;
+	let answer;
+	try {
+		answer = await resend.batch.send(valid.flatMap((index) => {
+			const item = items[index];
+			return item === void 0 ? [] : [payloadOf(item.target, item.message, item.options)];
+		}), { idempotencyKey: key });
+	} catch {
+		answer = void 0;
+	}
+	for (const [offset, index] of valid.entries()) {
+		if (answer === void 0) {
+			results[index] = UNAVAILABLE;
+			continue;
+		}
+		if (answer.error !== null) {
+			results[index] = resendFailure(answer.error);
+			continue;
+		}
+		const id = answer.data.data[offset]?.id;
+		results[index] = id === void 0 ? UNAVAILABLE : {
+			status: "sent",
+			providerId: id
+		};
+	}
+	return results;
+}
+/**
+* Sends the email channel of `permdock/delivery` through Resend. The
+* idempotency key is Resend's `idempotencyKey`. The delivery id, key and
+* category travel as tags, so `resendWebhook` can join provider events to
+* the delivery. Two or more recipients go out through `batch.send`, up to
+* 100 per call. Throws a `TypeError` for a tag outside Resend's charset.
+*/
+function resendTransport(resend, options = {}) {
+	const tags = checkTags(options.tags ?? {});
+	const payloadOf = (target, email, transportOptions) => compact({
+		from: email.from,
+		to: [target.address],
+		replyTo: email.replyTo ?? options.replyTo,
+		subject: email.subject,
+		text: email.text,
+		html: email.html,
+		headers: { ...email.headers },
+		tags: [
+			...tags,
+			...TAG.test(transportOptions.delivery) ? [{
+				name: DELIVERY_TAG,
+				value: transportOptions.delivery
+			}] : [],
+			{
+				name: KEY_TAG,
+				value: transportOptions.idempotencyKey
+			},
+			{
+				name: CATEGORY_TAG,
+				value: email.category
+			}
+		]
+	});
+	return Object.freeze(compact({
+		channel: "email",
+		name: "resend",
+		from: options.from,
+		batchSize: 100,
+		async deliver(target, email, transportOptions) {
+			if (!isDeliveryTarget(target, "email")) return REFUSED;
+			try {
+				const { data, error } = await resend.emails.send(payloadOf(target, email, transportOptions), { idempotencyKey: transportOptions.idempotencyKey });
+				if (error !== null) return resendFailure(error);
+				return {
+					status: "sent",
+					providerId: data.id
+				};
+			} catch {
+				return UNAVAILABLE;
+			}
+		},
+		deliverBatch: resend.batch === void 0 ? void 0 : (items) => sendBatch(resend, items, payloadOf)
+	}));
+}
+//#endregion
+//#region src/resend/webhook.ts
+/** Resend allows 5 minutes of clock skew either way; a claim outlives both. */
+const CLAIM_SECONDS = 600;
+const MAX_BODY = 1e6;
+const CATEGORIES = /* @__PURE__ */ new Set([
+	"transactional",
+	"notification",
+	"security",
+	"approval"
+]);
+function header(request, name) {
+	return request.headers.get(`svix-${name}`) ?? request.headers.get(`webhook-${name}`);
+}
+function text(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function joined(...parts) {
+	const found = parts.map(text).filter((part) => part !== void 0);
+	return found.length === 0 ? void 0 : found.join(": ");
+}
+function outcomeOf(type, data) {
+	switch (type) {
+		case "email.delivered": return { operation: "delivered" };
+		case "email.complained": return { operation: "complained" };
+		case "email.bounced": {
+			const bounce = ownRecord(data["bounce"]);
+			return compact({
+				operation: "bounced",
+				reason: joined(bounce?.["type"], bounce?.["message"])
+			});
+		}
+		case "email.failed": return compact({
+			operation: "failed",
+			cause: "rejected",
+			retryable: false,
+			reason: text(ownRecord(data["failed"])?.["reason"])
+		});
+		case "email.suppressed": {
+			const suppressed = ownRecord(data["suppressed"]);
+			return compact({
+				operation: "failed",
+				cause: "suppressed",
+				retryable: false,
+				reason: joined(suppressed?.["type"], suppressed?.["message"])
+			});
+		}
+		default: return;
+	}
+}
+/**
+* The delivery event a verified Resend payload stands for, or `null` for
+* one that is not about a PermDock delivery: opens and clicks (tracking,
+* not delivery), sends, contact and domain events, and mail without the
+* `permdock_delivery` and `permdock_key` tags.
+*/
+function eventOf(payload, source) {
+	const record = ownRecord(payload);
+	const data = ownRecord(record?.["data"]);
+	if (record === void 0 || data === void 0) return null;
+	const outcome = outcomeOf(record["type"], data);
+	const tags = ownRecord(data["tags"]);
+	const id = text(tags?.[DELIVERY_TAG]);
+	const key = text(tags?.[KEY_TAG]);
+	if (outcome === void 0 || id === void 0 || key === void 0) return null;
+	const category = tags?.[CATEGORY_TAG];
+	const at = record["created_at"];
+	return deliveryEvent(compact({
+		at: isRfc3339(at) ? at : void 0,
+		source,
+		channel: "email",
+		delivery: {
+			id,
+			key
+		},
+		category: typeof category === "string" && CATEGORIES.has(category) ? category : void 0,
+		provider: compact({
+			name: "resend",
+			id: text(data["email_id"])
+		}),
+		...outcome
+	}));
+}
+function unsigned() {
+	return problemResponse(statusProblem(400, "webhook signature headers are missing"));
+}
+function unverified() {
+	return problemResponse(statusProblem(403, "webhook signature did not verify"));
+}
+async function claim(replay, key) {
+	const expiresAt = nowSeconds() + CLAIM_SECONDS;
+	if (replay.claim !== void 0) return replay.claim(key, expiresAt);
+	if (await replay.seen(key)) return false;
+	await replay.remember(key, expiresAt);
+	return true;
+}
+/**
+* A fetch handler for Resend webhooks. It verifies the Standard Webhooks
+* signature through `resend.webhooks.verify` (the `svix-*` and `webhook-*`
+* header names both work), claims the message id, and writes one delivery
+* event for `email.delivered`, `email.bounced`, `email.complained`,
+* `email.failed` and `email.suppressed`. A bad signature is a `401`; a sink
+* failure releases the claim and answers `503`, so Resend retries.
+*/
+function resendWebhook(options) {
+	const source = options.source ?? "permdock";
+	return async (request) => {
+		if (request.method !== "POST") return methodNotAllowed("POST");
+		const id = header(request, "id");
+		const timestamp = header(request, "timestamp");
+		const signature = header(request, "signature");
+		if (id === null || timestamp === null || signature === null) return unsigned();
+		const read = await readBodyText(request, MAX_BODY);
+		if (!read.ok) return read.cause === "too-large" ? bodyTooLarge(MAX_BODY) : problemResponse(statusProblem(400, "webhook body was unreadable"));
+		const body = read.text;
+		let payload;
+		try {
+			payload = options.resend.webhooks.verify({
+				payload: body,
+				headers: {
+					id,
+					timestamp,
+					signature
+				},
+				webhookSecret: options.secret
+			});
+		} catch {
+			return unverified();
+		}
+		const replayKey = `resend:${id}`;
+		if (!await claim(options.replay, replayKey)) return new Response(null, { status: 200 });
+		const event = eventOf(payload, source);
+		if (event !== null) try {
+			await options.sink.write([event]);
+		} catch {
+			await options.replay.release?.(replayKey);
+			return problemResponse(statusProblem(503, "the event sink is unavailable"));
+		}
+		return new Response(null, { status: 200 });
+	};
+}
+//#endregion
+export { approvalEmail, resendFailure, resendTransport, resendWebhook };

package/dist/{resource-relations-D1Un3pcz.js → resource-relations-D_jw0BFx.js}

@@ -1,4 +1,4 @@
-import { a as assertSafeKey } from "./thenable-QSmvt-vZ.js";
+import { t as assertSafeKey } from "./paths-DXSHAMIa.js";
 //#region src/core/resource-relations.ts
 /** The edge's group resources with their relation and id column. */
 function groupEntries(spec) {

package/dist/{retire-BFcxL6un.js → retire-CALjIQ7e.js}

@@ -1,5 +1,5 @@
-import { n as escapeSqlIdent } from "./sql-t8teWOfo.js";
-import { a as RETIRE_MARKER } from "./markers-CiwAOZtO.js";
+import { r as escapeSqlIdent } from "./sql-B5T1IL83.js";
+import { a as RETIRE_MARKER } from "./markers-C6joDI3o.js";
 import { r as tableKey } from "./deciding-columns-Sq12mEA6.js";
 //#region src/cli/rls/retire.ts
 const IDENT = String.raw`(?:"[^"]+"|[A-Za-z_][\w$]*)`;

package/dist/{revocations-Cy06JNx2.d.ts → revocations-R07lFBnX.d.ts}

@@ -12,6 +12,8 @@ type RevocationListener = (event: RevocationEvent) => void;
  * revalidate a connection, never grant; a lost event falls back to expiry.
  */
 type RevocationFeed = {
+  /** Names the implementation in errors and events. */
+  readonly name?: string;
   subscribe(listener: RevocationListener): () => void;
   revoke(event: RevocationEvent): void | Promise<void>;
 };