@vercel/board 0.29.0 → 0.31.0

package/dist/{auth-JO22iIwr.mjs → auth-CyO2aw5n.mjs}

@@ -1,229 +1,14 @@
-import { c as ChannelPath, v as SCOPE_MAX } from "./schemas-DBmUO6pr.mjs";
-import { a as forbidden, l as unauthorized } from "./errors-CusN4x2l.mjs";
-//#region src/server/access.ts
-/**
-* What a principal may do in a channel. `read` covers messages, threads,
-* `/events`, and schedules; `post` starts threads and edits your own messages;
-* `manage` is the board's own bookkeeping (inbox, sources).
-*/
-const PERMISSIONS = [
-	"read",
-	"post",
-	"react",
-	"label",
-	"sync",
-	"manage"
-];
-/**
-* One hop of implication, kept as data like Vercel's git broker
-* (`ACTION_IMPLICATIONS`). Each verb that addresses a message by ID implies
-* `read`, so none of them is a blind existence oracle. `post` implies nothing:
-* write-only is `['post']`.
-*/
-const IMPLIES = {
-	read: [],
-	post: [],
-	react: ["read"],
-	label: ["read"],
-	sync: ["read"],
-	manage: [
-		"read",
-		"post",
-		"react",
-		"label",
-		"sync"
-	]
-};
-const ORDER = new Map(PERMISSIONS.map((permission, index) => [permission, index]));
-const SHAPE = "write *, a channel, or a channel and its subtree (feedback/)";
-/** A pattern's parts; any other `*` throws, and says what to type instead. */
-function parsePattern(pattern) {
-	if (pattern === "*") return { kind: "all" };
-	if (pattern.includes("*")) {
-		const before = pattern.slice(0, pattern.indexOf("*")).replace(/\/+$/, "");
-		const hint = before === "" ? "write * for every channel" : ChannelPath.safeParse(before).success ? `write ${before}/ for ${before} and its subtree` : SHAPE;
-		throw new Error(`invalid channel pattern ${pattern}: ${hint}`);
-	}
-	const subtree = pattern.endsWith("/");
-	const path = subtree ? pattern.slice(0, -1) : pattern;
-	if (!ChannelPath.safeParse(path).success) throw new Error(`invalid channel pattern ${pattern || "(empty)"}: ${SHAPE}`);
-	return subtree ? {
-		kind: "subtree",
-		path
-	} : {
-		kind: "exact",
-		path
-	};
-}
-const key = (pattern) => pattern.kind === "all" ? "*" : pattern.kind === "subtree" ? `${pattern.path}/` : pattern.path;
-/** A grant with its implications, closed: `['label']` is `read` and `label`. */
-function expand(grant) {
-	const out = /* @__PURE__ */ new Set();
-	const add = (permission) => {
-		if (!ORDER.has(permission)) throw new Error(`unknown permission ${String(permission)}: use ${PERMISSIONS.join(", ")}`);
-		if (out.has(permission)) return;
-		out.add(permission);
-		for (const implied of IMPLIES[permission]) add(implied);
-	};
-	for (const permission of grant === "all" ? PERMISSIONS : grant) add(permission);
-	return out;
-}
-const NOTHING = /* @__PURE__ */ new Set();
-function compile(entries) {
-	let all = null;
-	const exact = /* @__PURE__ */ new Map();
-	const subtrees = [];
-	for (const [pattern, permissions] of entries) if (pattern.kind === "all") all = permissions;
-	else if (pattern.kind === "exact") exact.set(pattern.path, permissions);
-	else subtrees.push([pattern.path, permissions]);
-	subtrees.sort((a, b) => b[0].length - a[0].length);
-	return {
-		all,
-		exact,
-		subtrees
-	};
-}
-const under = (channel, path) => channel === path || channel.startsWith(`${path}/`);
-/** What the most specific pattern covering `channel` gives; with `subtreeOnly`, ignoring an exact rule for it. */
-function resolve(rules, channel, subtreeOnly = false) {
-	if (!subtreeOnly) {
-		const exact = rules.exact.get(channel);
-		if (exact) return exact;
-	}
-	for (const [path, permissions] of rules.subtrees) if (under(channel, path)) return permissions;
-	return rules.all ?? NOTHING;
-}
-/**
-* What `rules` gives every channel `pattern` governs where nothing more
-* specific does. The patterns matching one channel form a chain, so that's one
-* answer: an exact channel resolves as itself, a subtree as whatever covers the
-* subtree's root, ignoring an exact rule for the root.
-*/
-const at = (rules, pattern) => pattern.kind === "all" ? rules.all ?? NOTHING : resolve(rules, pattern.path, pattern.kind === "subtree");
-const equal = (a, b) => a.size === b.size && [...a].every((permission) => b.has(permission));
-/** The answer of the pattern next less specific than `pattern` in `rules`. */
-function parent(rules, pattern) {
-	if (pattern.kind === "exact") return resolve(rules, pattern.path, true);
-	if (pattern.kind === "subtree") {
-		for (const [path, permissions] of rules.subtrees) if (path !== pattern.path && under(pattern.path, path)) return permissions;
-	}
-	return rules.all ?? NOTHING;
-}
-/** Drops rules that say what their parent says, and an empty `*`, so equal access has one summary. */
-function canonical(entries) {
-	const rules = compile(entries);
-	return compile(entries.filter(([pattern, permissions]) => pattern.kind === "all" ? permissions.size > 0 : !equal(permissions, parent(rules, pattern))));
-}
-function entriesOf(can) {
-	if (can === "all" || Array.isArray(can)) return [[{ kind: "all" }, expand(can)]];
-	return Object.entries(can).map(([pattern, grant]) => [parsePattern(pattern), expand(grant)]);
-}
-const entriesIn = (rules) => [
-	...rules.all ? [[{ kind: "all" }, rules.all]] : [],
-	...rules.subtrees.map(([path, permissions]) => [{
-		kind: "subtree",
-		path
-	}, permissions]),
-	...[...rules.exact].map(([path, permissions]) => [{
-		kind: "exact",
-		path
-	}, permissions])
-];
-const RULES = Symbol("board.access");
-const isAccess = (value) => typeof value === "object" && RULES in value;
-function fromRules(rules) {
-	const entries = entriesIn(rules);
-	const everywhere = (permission) => (rules.all?.has(permission) ?? false) && entries.every(([, permissions]) => permissions.has(permission));
-	const readable = /* @__PURE__ */ new Map();
-	return {
-		[RULES]: rules,
-		can: (permission, channel) => resolve(rules, channel).has(permission),
-		readable(channel) {
-			let found = readable.get(channel);
-			if (found === void 0) readable.set(channel, found = resolve(rules, channel).has("read"));
-			return found;
-		},
-		readsAll: everywhere("read"),
-		everywhere,
-		anywhere: (permission) => entries.some(([, permissions]) => permissions.has(permission)),
-		narrow(scope) {
-			const other = isAccess(scope) ? scope[RULES] : canonical(entriesOf(scope));
-			const patterns = /* @__PURE__ */ new Map([["*", { kind: "all" }]]);
-			for (const [pattern] of [...entries, ...entriesIn(other)]) patterns.set(key(pattern), pattern);
-			return fromRules(canonical([...patterns.values()].map((pattern) => {
-				const theirs = at(other, pattern);
-				return [pattern, new Set([...at(rules, pattern)].filter((permission) => theirs.has(permission)))];
-			})));
-		},
-		summary() {
-			const named = entries.map(([pattern, permissions]) => [key(pattern), permissions]);
-			named.sort(([a], [b]) => a === "*" ? -1 : b === "*" ? 1 : a.localeCompare(b));
-			const out = {};
-			for (const [name, permissions] of named) out[name] = [...permissions].sort((a, b) => ORDER.get(a) - ORDER.get(b));
-			return out;
-		}
-	};
-}
-/** Access from config: `'all'`, a list for every channel, or a map from pattern to grant. Throws on a bad pattern or permission. */
-function compileAccess(can) {
-	return fromRules(canonical(entriesOf(can)));
-}
-const FULL_ACCESS = compileAccess("all");
-/**
-* `x-board-scope`: `dev/=read,post,react,label;ci/=read`. Each entry is a
-* pattern and its permissions (or `all`). It's meant for a proxy that holds the
-* credential, like Pi's sandbox: the board intersects it with the principal's
-* access, so it can only narrow, and a caller holding its own token gains
-* nothing by sending it.
-*/
-function parseScope(header) {
-	if (header.length > 4e3) throw new Error(`x-board-scope is longer than ${SCOPE_MAX} characters`);
-	const out = {};
-	const entries = header.split(";").map((entry) => entry.trim());
-	if (entries.every((entry) => entry === "")) throw new Error("x-board-scope is empty: write pattern=permissions, like dev/=read,post");
-	for (const entry of entries) {
-		if (entry === "") continue;
-		const split = entry.indexOf("=");
-		if (split < 0) throw new Error(`x-board-scope entry ${entry} needs =: write pattern=permissions, like dev/=read,post`);
-		const pattern = entry.slice(0, split).trim();
-		const list = entry.slice(split + 1).trim();
-		if (Object.hasOwn(out, pattern)) throw new Error(`x-board-scope lists ${pattern} twice`);
-		parsePattern(pattern);
-		const permissions = list === "" ? [] : list.split(",").map((permission) => permission.trim());
-		if (permissions.length === 1 && permissions[0] === "all") {
-			out[pattern] = "all";
-			continue;
-		}
-		for (const permission of permissions) if (!ORDER.has(permission)) throw new Error(`x-board-scope: unknown permission ${permission || "(empty)"}: use ${PERMISSIONS.join(", ")}, or all`);
-		out[pattern] = permissions;
-	}
-	return out;
-}
-const PHRASE = {
-	read: (channel) => `read ${channel}`,
-	post: (channel) => `post in ${channel}`,
-	react: (channel) => `react in ${channel}`,
-	label: (channel) => `label in ${channel}`,
-	sync: (channel) => `sync in ${channel}`,
-	manage: (channel) => `manage ${channel}`
-};
+import { a as forbidden, l as unauthorized, r as badRequest } from "./errors-CJXhhzvT.mjs";
+import { i as parseScope, o as union, r as compileAccess, t as FULL_ACCESS } from "./access-CY5xVMIK.mjs";
+//#region src/server/auth.ts
 /**
-* A proof that `access` allows `permission` in `channel`, or a 403 naming what's
-* missing: `this token can't label in dev`. Pass the channel the board looked
-* up, never one the request named. What the caller can't read should answer as
-* if it didn't exist: pass that error as `hidden`, and it's thrown instead
-* whenever `channel` isn't readable.
+* Whether a caller wrote what `by` says, as far as changing it goes (editing, deleting, canceling a
+* schedule): its principal did, and when a board token pins the profile it writes as, as that
+* profile. A token acts as its minter, so the principal alone would let one agent's token change
+* what its minter or another agent wrote. Another token that pins the same profile writes as the
+* same author, so a renewed one picks up where the last left off.
 */
-function authorize(access, permission, channel, hidden) {
-	if (hidden && !access.readable(channel)) throw hidden();
-	if (!access.can(permission, channel)) throw forbidden(`this token can't ${PHRASE[permission](channel)}`);
-	return Object.freeze({
-		permission,
-		channel
-	});
-}
-//#endregion
-//#region src/server/auth.ts
+const wroteAs = (caller, by) => by.principal === caller.principal.id && ((caller.principal.pinned?.profile ?? null) === null || by.actor === caller.actor.id);
 /**
 * Principal IDs a board authenticates: its people, deployments, workflows, and its own code. No
 * platform actor sync writes as may have one, or an import could pass for someone signed in.
@@ -322,11 +107,101 @@ function trustedIssuers(issuers) {
 }
 /** The OIDC issuers rules name: the only ones whose tokens are verified for them. */
 const issuersOf = (rules) => [...new Set(rules.flatMap((rule) => typeof rule !== "function" && rule.issuer === "oidc" ? [rule.url] : []))];
+/** What a board token starts with, so board() knows its own before it tries any other verifier. */
+const BOARD_TOKEN_PREFIX = "board_";
+/**
+* A board token's SHA-256, hex: what the board keeps instead of the secret, both when it mints one
+* and when a request carries one. A token is 32 random bytes, so no salt or key is needed.
+*/
+async function tokenHash(secret) {
+	const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(secret)));
+	return Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/** What a grant or a token left without `can` gives: what Vercel's API gives a project it lets use a board. */
+const DEFAULT_CAN = { "*": [
+	"read",
+	"post",
+	"react",
+	"label"
+] };
+const GRANT_CLAIMS_MAX = 32;
+const GRANT_VALUES_MAX = 32;
+const GRANT_VALUE_MAX = 1e3;
+const invalidGrant = (message) => badRequest(message, "invalid_grant");
+/** Whether `host` names something on the board's own network rather than on the internet. */
+function privateHost(host) {
+	const name = host.toLowerCase().replace(/\.$/, "");
+	if (name.startsWith("[") || /^\d+(\.\d+){3}$/.test(name) || /^\d+$/.test(name)) return true;
+	if (!name.includes(".") || name === "localhost") return true;
+	return /\.(localhost|local|internal|home|lan|corp|intranet)$/.test(name);
+}
+/**
+* A grant checked and put in one form: its issuer, its claims with keys and lists sorted, its
+* `can`, and the key that says it's the same grant as another. A 400 `invalid_grant` that says
+* what to write. `trusted`: the issuers the board's rules and other grants name, which no two may
+* share principals between.
+*/
+function checkGrant(spec, trusted) {
+	const { issuer } = spec;
+	if (typeof issuer !== "string" || issuer === "") throw invalidGrant("a grant needs an issuer: vercel, github, or an https URL");
+	if (issuer !== "vercel" && issuer !== "github") {
+		let url;
+		try {
+			url = new URL(issuer);
+		} catch {
+			throw invalidGrant(`a grant's issuer is vercel, github, or an https URL, got ${issuer}`);
+		}
+		if (VERCEL_ISSUER.test(issuer)) throw invalidGrant("write the issuer as vercel, and another team's projects with owner_id");
+		if (issuer === "https://token.actions.githubusercontent.com") throw invalidGrant("write the issuer as github");
+		if (url.protocol !== "https:" || url.search || url.hash || url.username || url.password) throw invalidGrant(`a grant's issuer is an https URL with no query or credentials, got ${issuer}`);
+		if (privateHost(url.hostname)) throw invalidGrant(`a grant's issuer is on the internet, not ${url.hostname}`);
+		const name = issuerName(issuer);
+		const other = trusted.find((candidate) => candidate !== issuer && /^https:/.test(candidate) && issuerName(candidate) === name);
+		if (other !== void 0) throw invalidGrant(`issuers ${other} and ${issuer} name the same principals, oidc:${name}:<sub>: use ${other}`);
+	}
+	const entries = typeof spec.claims === "object" && spec.claims !== null ? Object.entries(spec.claims) : [];
+	if (entries.length === 0) throw invalidGrant(`name at least one claim for ${issuer}: its issuer signs tokens for everyone it serves`);
+	if (entries.length > GRANT_CLAIMS_MAX) throw invalidGrant(`a grant names at most ${GRANT_CLAIMS_MAX} claims`);
+	const claims = {};
+	for (const [name, value] of entries.sort(([a], [b]) => a.localeCompare(b))) {
+		const values = typeof value === "string" ? [value] : Array.isArray(value) ? [...new Set(value)] : [];
+		if (values.length === 0 || values.some((one) => typeof one !== "string" || one === "")) throw invalidGrant(`claim ${name} has no value to match: give a string, or a list of them`);
+		if (values.length > GRANT_VALUES_MAX || values.some((one) => one.length > GRANT_VALUE_MAX)) throw invalidGrant(`claim ${name} lists at most ${GRANT_VALUES_MAX} values of up to ${GRANT_VALUE_MAX} characters`);
+		const sorted = values.sort();
+		claims[name] = sorted.length === 1 ? sorted[0] : sorted;
+	}
+	if (issuer === "vercel" && (claims.project_id === void 0 || claims.environment === void 0)) throw invalidGrant("a Vercel grant names project_id and environment: a preview runs any branch, so it says outright whether they get in");
+	if (issuer === "github" && claims.repository === void 0 && claims.repository_id === void 0) throw invalidGrant("a GitHub grant names repository or repository_id: GitHub signs tokens for every repository");
+	const can = spec.can ?? DEFAULT_CAN;
+	try {
+		compileAccess(can);
+	} catch (error) {
+		throw invalidGrant(error.message);
+	}
+	return {
+		issuer,
+		claims,
+		can,
+		key: JSON.stringify([issuer, claims])
+	};
+}
+/** Whether a verified token's facts are a grant's: its issuer, and every claim it names. */
+function grantMatches(grant, facts) {
+	if (!(grant.issuer === "vercel" || grant.issuer === "github" ? facts.issuer === grant.issuer : facts.issuer === "oidc" && facts.iss === grant.issuer)) return false;
+	return Object.entries(grant.claims).every(([name, allowed]) => {
+		const value = facts.claims[name];
+		if (value === void 0) return false;
+		const text = String(value);
+		return typeof allowed === "string" ? text === allowed : allowed.includes(text);
+	});
+}
+/** The OIDC issuers grants name past Vercel and GitHub: their tokens are verified too. */
+const grantIssuers = (grants) => [...new Set(grants.flatMap((grant) => grant.issuer === "vercel" || grant.issuer === "github" ? [] : [grant.issuer]))];
 /**
 * What principals may do, under a board's rules: `vercelProject()`, `githubActions()`, `oidc()`,
-* and functions of your own, the first that matches deciding, past the defaults (people, and the
-* board's own deployments in its environment, may do everything). Or a host's own function of the
-* principal.
+* and functions of your own, the first that matches deciding, with the board's grants adding to it,
+* past the defaults (people, and the board's own deployments in its environment, may do
+* everything). Or a host's own function of the principal.
 */
 function createAuthority(options) {
 	const rules = typeof options.access === "function" ? [] : options.access;
@@ -334,13 +209,14 @@ function createAuthority(options) {
 	const oidcIssuers = trustedIssuers(issuersOf(rules));
 	/**
 	* What the rules give a principal, in order: a token's rule when its facts match, a function when
-	* it answers. The board's own deployments in its environment get everything unless a token's rule
-	* says otherwise, and no function is asked about them. A 401 or 403 that says which rule would let
-	* it in, when none does.
+	* it answers. Every grant that matches its token adds to that, so a grant never goes unused
+	* because a rule matched first. The board's own deployments in its environment get everything
+	* unless a token's rule says otherwise, no function is asked about them, and no grant is theirs;
+	* a function that answers null refuses, grants or not. A 401 or 403 that says which rule would
+	* let it in, when nothing does.
 	*/
 	async function byRules(principal, facts) {
 		if (facts?.issuer === "host") throw forbidden("this token can't use this board: its board no longer takes a host's principals");
-		if (facts?.issuer === "oidc" && !oidcIssuers.has(facts.iss)) throw unauthorized(`untrusted issuer: ${facts.iss}`);
 		const claims = facts?.claims ?? {};
 		const own = facts?.issuer === "vercel" ? await options.project() : null;
 		const context = own ? {
@@ -354,18 +230,32 @@ function createAuthority(options) {
 		const here = boardEnvironment();
 		const ownDeployment = own !== null && own.id !== null && claims.project_id === own.id;
 		const ownHere = ownDeployment && here !== null && environment === here;
+		let ruled = null;
 		for (const rule of rules) {
 			if (typeof rule === "function") {
 				if (ownHere) continue;
 				const can = await rule(principal);
 				if (can === void 0) continue;
 				if (can === null) throw forbidden("this token can't use this board");
-				return compileAccess(can);
+				ruled = compileAccess(can);
+				break;
 			}
-			if (facts && rule.issuer === facts.issuer && (rule.issuer !== "oidc" || rule.url === facts.iss) && rule.matches(claims, context)) return rule.access;
+			if (facts && rule.issuer === facts.issuer && (rule.issuer !== "oidc" || rule.url === facts.iss) && rule.matches(claims, context)) {
+				ruled = rule.access;
+				break;
+			}
+		}
+		if (ownHere) return ruled ?? FULL_ACCESS;
+		if (!facts) {
+			if (ruled) return ruled;
+			throw forbidden("this token can't use this board");
 		}
-		if (ownHere) return FULL_ACCESS;
-		if (!facts) throw forbidden("this token can't use this board");
+		const grants = options.grants ? await options.grants() : [];
+		const granted = grants.filter((grant) => grantMatches(grant, facts)).map((grant) => compileAccess(grant.can));
+		if (ruled) return granted.length > 0 ? union([ruled, ...granted]) : ruled;
+		if (granted.length > 0) return union(granted);
+		if (facts.issuer === "oidc" && !oidcIssuers.has(facts.iss) && !grants.some((grant) => grant.issuer === facts.iss)) throw unauthorized(`untrusted issuer: ${facts.iss}`);
+		if (facts.issuer === "oidc" && !oidcIssuers.has(facts.iss)) throw forbidden("this token can't use this board: no grant lets in its claims");
 		if (facts.issuer === "oidc") throw notInAccess(`oidc({ issuer: '${facts.iss}', claims, can })`);
 		if (facts.issuer === "github") throw notInAccess(`githubActions({ repository: '${String(claims.repository)}', can })`);
 		if (ownDeployment) throw forbidden(`this token can't use this board: it runs in ${here ?? "no Vercel environment"}, so its ${environment || "unnamed"} deployments need vercelProject({ project: 'self', environments: ['${environment}'], can })`);
@@ -496,4 +386,4 @@ function hostPrincipal(value) {
 	};
 }
 //#endregion
-export { FULL_ACCESS as _, compileRules as a, githubActions as c, issuersOf as d, markVerified as f, verifiesTokens as g, vercelProject as h, authenticates as i, hostPrincipal as l, trustedIssuers as m, TOKENS as n, createAuthority as o, oidc as p, VERCEL_ISSUER as r, fromTokens as s, GITHUB_ISSUER as t, issuerName as u, authorize as v, parseScope as y };
+export { wroteAs as C, verifiesTokens as S, oidc as _, VERCEL_ISSUER as a, trustedIssuers as b, compileRules as c, githubActions as d, grantIssuers as f, markVerified as g, issuersOf as h, TOKENS as i, createAuthority as l, issuerName as m, DEFAULT_CAN as n, authenticates as o, hostPrincipal as p, GITHUB_ISSUER as r, checkGrant as s, BOARD_TOKEN_PREFIX as t, fromTokens as u, privateHost as v, vercelProject as x, tokenHash as y };

package/dist/{auth-CU56Q2Xh.d.mts → auth-DLYSt_-A.d.mts}

@@ -1,4 +1,4 @@
-import { r as Can, t as Access } from "./access-CV96SYgr.mjs";
+import { r as Can, t as Access } from "./access-DPcrKIH_.mjs";
 import { JWTPayload, JWTVerifyGetKey } from "jose";
 //#region src/server/auth.d.ts
 /**
@@ -46,6 +46,22 @@ type Principal = {
   facts?: TokenFacts;
   /** The `x-board-scope` a proxy sent, which narrows whatever it may do. */
   scope?: string;
+  /**
+   * The board token it came with (its ID), kept with what it stores: a schedule or a registration
+   * made with one stops when the token does.
+   */
+  token?: string;
+  /** What a board token pins for every request with it: the profile, avatar, and session it writes as, and a person's handle and name. */
+  pinned?: Pinned;
+};
+/** What a board token says about who writes, beside its principal: labels, but the board's, so a request can't change them. */
+type Pinned = {
+  profile: string | null;
+  avatar: string | null;
+  session: string | null;
+  /** A person's handle and display name as they were when they minted it: whoever holds the token sends none. */
+  handle: string | null;
+  name: string | null;
 };
 /** A principal and what it may do in each channel, as board()'s `access` worked it out. */
 type Granted = Principal & {
@@ -154,8 +170,20 @@ type AccessFunction = (principal: Known) => Can | null | undefined | Promise<Can
  * person or the board's own deployments in its environment, which the defaults decide first.
  */
 type RuleFunction = (principal: Known) => Can | null | undefined | Promise<Can | null | undefined>;
-/** A principal as the board keeps it to work its access out again: who it is, its token's facts, and its scope. */
-type Known = Pick<Principal, 'id' | 'kind' | 'handle' | 'facts' | 'scope'>;
+/** A principal as the board keeps it to work its access out again: who it is, its token's facts, its scope, and the board token it came with. */
+type Known = Pick<Principal, 'id' | 'kind' | 'handle' | 'facts' | 'scope' | 'token'>;
+/** A grant the board keeps: its ID, its issuer and claims as the board checked them, and who set it when. */
+type StoredGrant = {
+  id: string;
+  issuer: string;
+  claims: Readonly<Record<string, string | readonly string[]>>;
+  can: Can;
+  /** The actor that last set it, and when. */
+  by: string;
+  at: string;
+};
+/** What a grant or a token left without `can` gives: what Vercel's API gives a project it lets use a board. */
+declare const DEFAULT_CAN: Can;
 /**
  * What a principal may do under `rules` (`vercelProject()`, `githubActions()`, `oidc()`, and
  * functions of your own), the first that matches deciding, past the defaults: people, and the
@@ -201,4 +229,4 @@ type HostPrincipal = {
   expiresAt?: Date | null;
 };
 //#endregion
-export { oidc as _, CallerRequest as a, HostPrincipal as c, OidcTokensOptions as d, Principal as f, githubActions as g, compileRules as h, AuthenticateContext as i, IssuerConfig as l, RuleFunction as m, AccessRule as n, Claims as o, PrincipalKind as p, Authenticate as r, Granted as s, AccessFunction as t, Known as u, vercelProject as v };
+export { StoredGrant as _, CallerRequest as a, oidc as b, Granted as c, Known as d, OidcTokensOptions as f, RuleFunction as g, PrincipalKind as h, AuthenticateContext as i, HostPrincipal as l, Principal as m, AccessRule as n, Claims as o, Pinned as p, Authenticate as r, DEFAULT_CAN as s, AccessFunction as t, IssuerConfig as u, compileRules as v, vercelProject as x, githubActions as y };