@vercel/board 0.0.0 → 0.16.0

package/dist/auth-COzc09sn.mjs

@@ -0,0 +1,276 @@
+import { a as forbidden, l as unauthorized } from "./errors-DX3hpwWt.mjs";
+import { i as parseScope, r as compileAccess, t as FULL_ACCESS } from "./access-CJU2-vaa.mjs";
+//#region src/server/auth.ts
+/**
+* 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.
+*/
+const authenticates = (id) => /^(vercel|oidc|local|board):/.test(id) || id.startsWith("github:repo:");
+/** A token no rule matches, and the rule that would let it in. */
+const notInAccess = (rule) => forbidden(`this token can't use this board: add ${rule} to access`);
+/** A rule's `can`, compiled. A rule without one says which rule and what to write. */
+function accessOf(rule, can) {
+	if (can === void 0 || can === null) throw new Error(`${rule} needs can: say what it may do, like can: { 'ci/': ['read', 'post'] }, or can: 'all'`);
+	return compileAccess(can);
+}
+const oneOf = (value, allowed) => allowed === void 0 || typeof value === "string" && (typeof allowed === "string" ? [allowed] : allowed).includes(value);
+/**
+* A Vercel project's deployments, by name or ID. A name is only unique within
+* a team, so without `team` it means the board's own team, and matches nothing
+* when that isn't known. An ID is unique on Vercel, so it matches on any team.
+* `'self'` is the board's own project: its deployments in the environment the
+* board runs in have full access unless a rule says otherwise, and its other
+* environments have none unless one lists them. Its development tokens are
+* people, which no rule changes.
+*/
+function vercelProject(options) {
+	if (options.project === "self" && options.team !== void 0) throw new Error("vercelProject({ project: 'self' }) is the board's own project: drop team");
+	return {
+		issuer: "vercel",
+		access: accessOf(`vercelProject({ project: '${options.project}' })`, options.can),
+		matches: (claims, { teamId, projectId }) => (options.project === "self" ? projectId !== null && claims.project_id === projectId : claims.project_id === options.project || claims.project === options.project && (options.team === void 0 ? teamId !== null && claims.owner_id === teamId : claims.owner === options.team || claims.owner_id === options.team)) && oneOf(claims.environment, options.environments)
+	};
+}
+/**
+* A GitHub Actions workflow. A `pull_request` run's token carries
+* `ref: refs/pull/<n>/merge`, so match those on `event` and `workflow`, not `ref`.
+*/
+function githubActions(options) {
+	return {
+		issuer: "github",
+		access: accessOf(`githubActions({ repository: '${options.repository}' })`, options.can),
+		matches: (claims) => claims.repository === options.repository && oneOf(claims.event_name, options.event) && (options.ref === void 0 || claims.ref === options.ref) && (options.workflow === void 0 || typeof claims.workflow_ref === "string" && claims.workflow_ref.startsWith(`${options.repository}/${options.workflow}@`))
+	};
+}
+/**
+* Any OIDC issuer's tokens: GitLab, Buildkite, a cloud's workload identity.
+* The issuer is pinned here, and only issuers some rule names are trusted or
+* have their keys fetched. Every listed claim must match exactly (a list is
+* any of its values), and there must be at least one, since an issuer signs
+* tokens for everyone it serves. The principal is `oidc:<issuer host and path>:<sub>`,
+* with any `:` or `%` in the issuer part percent-encoded, so it ends at the first `:`.
+*/
+function oidc(options) {
+	let url;
+	try {
+		url = new URL(options.issuer);
+	} catch {
+		throw new Error(`oidc: issuer must be a URL, got ${options.issuer}`);
+	}
+	if (url.protocol !== "https:" || url.search || url.hash || url.username || url.password) throw new Error(`oidc: issuer must be an https URL with no query or credentials, got ${options.issuer}`);
+	if (VERCEL_ISSUER.test(options.issuer)) throw new Error("oidc: use vercelProject() for Vercel tokens");
+	if (options.issuer === "https://token.actions.githubusercontent.com") throw new Error("oidc: use githubActions() for GitHub Actions tokens");
+	const required = Object.entries(options.claims);
+	if (required.length === 0) throw new Error(`oidc: name at least one claim to match for ${options.issuer}`);
+	for (const [name, allowed] of required) {
+		const values = typeof allowed === "string" ? [allowed] : Array.isArray(allowed) ? allowed : [];
+		if (values.length === 0 || values.some((value) => typeof value !== "string" || value === "")) throw new Error(`oidc: claim ${name} has no value to match for ${options.issuer}`);
+	}
+	return {
+		issuer: "oidc",
+		url: options.issuer,
+		access: accessOf(`oidc({ issuer: '${options.issuer}' })`, options.can),
+		matches: (claims) => required.every(([name, allowed]) => oneOf(claims[name], allowed))
+	};
+}
+const VERCEL_ISSUER = /^https:\/\/oidc\.vercel\.com(?:\/[a-z0-9-]+)?$/;
+const GITHUB_ISSUER = "https://token.actions.githubusercontent.com";
+/**
+* `gitlab.com`, `example.com/oidc`, `ci.test%3A8443`: an issuer as a principal
+* names it. A `:` (a port) and a `%` are percent-encoded, so the name has no `:`
+* and the `sub` after it can hold anything. Issuers that differ only in what the
+* URL normalizes (a trailing slash, the host's case) share a name, so the board
+* refuses to trust two of them.
+*/
+const issuerName = (iss) => {
+	const url = new URL(iss);
+	return `${url.host}${url.pathname.replace(/\/+$/, "")}`.replace(/[%:]/g, (char) => char === "%" ? "%25" : "%3A");
+};
+/** OIDC issuers to trust, checked: two that name the same principals can't both be. */
+function trustedIssuers(issuers) {
+	const named = /* @__PURE__ */ new Map();
+	for (const iss of issuers) {
+		const name = issuerName(iss);
+		const other = named.get(name);
+		if (other !== void 0 && other !== iss) throw new Error(`access: oidc issuers ${other} and ${iss} name the same principals, oidc:${name}:<sub>: pin one of them`);
+		named.set(name, iss);
+	}
+	return new Set(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 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.
+*/
+function createAuthority(options) {
+	const rules = typeof options.access === "function" ? [] : options.access;
+	const host = typeof options.access === "function" ? options.access : null;
+	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.
+	*/
+	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 ? {
+			teamId: facts.team ?? own.teamId,
+			projectId: own.id
+		} : {
+			teamId: null,
+			projectId: null
+		};
+		const environment = String(claims.environment ?? "");
+		const here = boardEnvironment();
+		const ownDeployment = own !== null && own.id !== null && claims.project_id === own.id;
+		const ownHere = ownDeployment && here !== null && environment === here;
+		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);
+			}
+			if (facts && rule.issuer === facts.issuer && (rule.issuer !== "oidc" || rule.url === facts.iss) && rule.matches(claims, context)) return rule.access;
+		}
+		if (ownHere) return FULL_ACCESS;
+		if (!facts) throw forbidden("this token can't use this board");
+		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 })`);
+		throw notInAccess(`vercelProject({ project: '${String(claims.project ?? "") || String(claims.project_id)}', can })`);
+	}
+	/**
+	* What a principal may do now, narrowed by its scope: the board's own code and the platform users
+	* sync writes as everything; anyone else what a host's function says, or under the rules, a person
+	* everything and anyone else whatever the first rule that matches gives. A host's principal is
+	* what its kind is, until it expires. A 401 or 403 when it may do nothing.
+	*/
+	async function grant(principal) {
+		let access = FULL_ACCESS;
+		const hosted = principal.facts?.issuer === "host";
+		if (principal.id.startsWith("board:") || principal.kind === "external" && !hosted) access = FULL_ACCESS;
+		else {
+			if (hosted) {
+				if (!options.hosts) throw forbidden("this token can't use this board: its board no longer takes a host's principals");
+				const { exp } = principal.facts.claims;
+				if (typeof exp === "number" && exp * 1e3 <= Date.now()) throw unauthorized("token expired");
+			}
+			if (host) {
+				const can = await host(principal);
+				if (can === null || can === void 0) throw forbidden("this token can't use this board");
+				access = compileAccess(can);
+			} else if (principal.kind !== "person") access = await byRules(principal, (hosted ? void 0 : principal.facts) ?? factsFromId(principal.id));
+		}
+		return principal.scope === void 0 ? access : access.narrow(parseScope(principal.scope));
+	}
+	/** What a stored principal (a schedule's creator, a watcher's registrant) may do now: null once nothing. */
+	async function accessNow(principal) {
+		try {
+			return await grant(principal);
+		} catch (error) {
+			const status = error.status;
+			if (status === 401 || status === 403) return null;
+			throw error;
+		}
+	}
+	return {
+		grant,
+		accessNow
+	};
+}
+/**
+* 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
+* board's own deployments in the environment it runs in, may do everything. Its scope narrows what
+* it gets. A 401 or 403 that names the rule that would let it in, when it may do nothing.
+*/
+function compileRules(rules, board) {
+	return createAuthority({
+		access: rules,
+		project: () => board.project(),
+		hosts: true
+	}).grant;
+}
+/**
+* The Vercel environment the board runs in: `production`, `preview`, or a
+* custom environment's name. `VERCEL_TARGET_ENV` names custom environments,
+* where `VERCEL_ENV` says `preview`. Null outside Vercel, where only people
+* get in without a rule.
+*/
+const boardEnvironment = () => process.env.VERCEL_TARGET_ENV || process.env.VERCEL_ENV || null;
+/**
+* What a principal's ID still says, for one stored before the board kept
+* claims: a deployment's project ID and environment. A workflow's ID names
+* neither its repository nor its run, so it says nothing, and a rule that
+* needs more than the ID no longer matches.
+*/
+function factsFromId(id) {
+	const deployment = id.match(/^vercel:project:([^:]+):([^:]+)$/);
+	return deployment ? {
+		issuer: "vercel",
+		iss: "",
+		claims: {
+			project_id: deployment[1],
+			environment: deployment[2]
+		}
+	} : null;
+}
+/** What marks `oidcTokens()`, so board() can tell it makes no host's principals. */
+const TOKENS = Symbol("board.oidcTokens");
+/** The principals `oidcTokens()` made: board() takes them as they are, and checks the rest as a host's. */
+const verifiedTokens = /* @__PURE__ */ new WeakSet();
+/** Marks a principal `oidcTokens()` made. */
+function markVerified(principal) {
+	verifiedTokens.add(principal);
+	return principal;
+}
+/** Whether `authenticate` is `oidcTokens()`'s alone: it makes no host's principals. */
+const verifiesTokens = (authenticate) => TOKENS in authenticate;
+/** Whether `oidcTokens()` made `principal`, as opposed to a host's own verifier. */
+const fromTokens = (principal) => verifiedTokens.has(principal);
+const PRINCIPAL_ID = /^[a-z][a-z0-9-]*:[a-z][a-z0-9-]*:[^\s+\]]{1,200}$/;
+const KINDS = [
+	"person",
+	"deployment",
+	"workflow",
+	"external"
+];
+/**
+* Checks what a host's own verifier returned. A malformed principal is the host's bug, so it
+* fails the request rather than letting a half-identity write.
+*/
+function hostPrincipal(value) {
+	const fail = (why) => {
+		throw new TypeError(`authenticate returned an invalid principal: ${why}`);
+	};
+	if (typeof value !== "object" || value === null) fail("not an object");
+	if (typeof value.id !== "string" || !PRINCIPAL_ID.test(value.id) || value.id.startsWith("board:")) fail(`id must look like \`vercel:user:<id>\`, got ${JSON.stringify(value.id)}`);
+	if (!KINDS.includes(value.kind)) fail(`kind must be one of ${KINDS.join(", ")}`);
+	if (typeof value.handle !== "string" || !/^\S{1,64}$/.test(value.handle)) fail("handle must be 1-64 characters, no spaces");
+	const expiresAt = value.expiresAt ?? null;
+	if (expiresAt !== null && (!(expiresAt instanceof Date) || Number.isNaN(expiresAt.getTime()))) fail("expiresAt must be a Date or null");
+	if (expiresAt !== null && expiresAt.getTime() <= Date.now()) throw unauthorized("token expired");
+	const claims = expiresAt === null ? {} : { exp: Math.floor(expiresAt.getTime() / 1e3) };
+	return {
+		id: value.id,
+		kind: value.kind,
+		handle: value.handle,
+		expiresAt,
+		facts: {
+			issuer: "host",
+			iss: "",
+			claims
+		}
+	};
+}
+//#endregion
+export { 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 };

package/dist/auth-CU56Q2Xh.d.mts

@@ -0,0 +1,204 @@
+import { r as Can, t as Access } from "./access-CV96SYgr.mjs";
+import { JWTPayload, JWTVerifyGetKey } from "jose";
+//#region src/server/auth.d.ts
+/**
+ * What a request says about who's calling, beside its credential: labels the caller picks for
+ * itself, under whoever the credential turns out to be. They're never security: board() uses them
+ * to work out the actor a verified caller writes as.
+ */
+type Claims = {
+  /** `x-board-profile`: the agent or tool it writes as, `claude`, say. */
+  profile: string | null;
+  /** `x-board-avatar`: an https URL for its picture. */
+  avatar: string | null;
+  /** `x-board-session`: the agent session it writes from. */
+  session: string | null;
+  /** `x-board-handle` and `x-board-name`: a person's handle and display name. */
+  handle: string | null;
+  name: string | null;
+  /** `x-board-scope`: what it narrows itself to, `dev/=read,post`. It only narrows. */
+  scope: string | null;
+};
+/** A request, as board() hands it to `authenticate`: what it said, none of it verified yet. */
+type CallerRequest = {
+  /** The bearer token, or null when it sent none. */
+  credential: string | null;
+  claims: Claims;
+  /** The board's URL, which a token must be minted for. */
+  audience: string;
+  /** Its headers, for a verifier that recognizes a session of its own: a same-site page's cookie, say. */
+  headers: Headers;
+};
+/** `external`: a platform user writing through sync (`slack:user:U0456`). A local board's people are `local:user:<name>`. */
+type PrincipalKind = 'person' | 'deployment' | 'workflow' | 'external';
+/**
+ * Who's calling, as board() verified it: an ID in the board's scheme and what its token said.
+ * What it may do is board()'s `access` to say.
+ */
+type Principal = {
+  /** `vercel:user:<id>`, `vercel:project:<id>:<env>`, `github:repo:<id>`, `oidc:<issuer>:<sub>`. */
+  id: string;
+  kind: PrincipalKind;
+  /** The default handle; a person's is replaced by the handle their CLI sends, unless a host's verifier named them. */
+  handle: string;
+  expiresAt: Date | null;
+  /** The verified token's claims, so its access can be worked out again later, as a schedule's sends do. Absent for people and the board's own code. */
+  facts?: TokenFacts;
+  /** The `x-board-scope` a proxy sent, which narrows whatever it may do. */
+  scope?: string;
+};
+/** A principal and what it may do in each channel, as board()'s `access` worked it out. */
+type Granted = Principal & {
+  access: Access;
+};
+/** A verified token's claims, as rules match them. */
+type TokenClaims = JWTPayload & Record<string, unknown>;
+/** What a verified token said: its issuer and its claims, never the token itself. */
+type TokenFacts = {
+  /** `host`: a host's own verifier recognized the caller; its claims are when that runs out. */
+  issuer: 'vercel' | 'github' | 'oidc' | 'host';
+  iss: string;
+  claims: Readonly<Record<string, string | number | boolean>>;
+  /**
+   * The board's own Vercel team, as the board knew it when it verified the
+   * token. A schedule's send may run where the board can't work it out (the
+   * scheduler's own function, with no request to learn it from), and a rule
+   * naming a project without its team needs it. Only the board writes it.
+   */
+  team?: string;
+};
+/** What a rule may compare claims to: the board's own Vercel team and project, when they're known. */
+type MatchContext = {
+  teamId: string | null;
+  projectId: string | null;
+};
+/** One entry in `board({ access })`: who it matches, and what they may do. The first entry that matches decides. */
+type AccessRule = {
+  /** `vercel` and `github` are their platforms' issuers; `oidc` is the exact `url`. */
+  issuer: 'vercel' | 'github' | 'oidc';
+  /** For `oidc`: the issuer URL, pinned in code. */
+  url?: string;
+  matches(claims: TokenClaims, context: MatchContext): boolean;
+  access: Access;
+};
+/**
+ * A Vercel project's deployments, by name or ID. A name is only unique within
+ * a team, so without `team` it means the board's own team, and matches nothing
+ * when that isn't known. An ID is unique on Vercel, so it matches on any team.
+ * `'self'` is the board's own project: its deployments in the environment the
+ * board runs in have full access unless a rule says otherwise, and its other
+ * environments have none unless one lists them. Its development tokens are
+ * people, which no rule changes.
+ */
+declare function vercelProject(options: {
+  project: string;
+  team?: string;
+  environments?: readonly string[];
+  can: Can;
+}): AccessRule;
+/**
+ * A GitHub Actions workflow. A `pull_request` run's token carries
+ * `ref: refs/pull/<n>/merge`, so match those on `event` and `workflow`, not `ref`.
+ */
+declare function githubActions(options: {
+  repository: string;
+  event?: string | readonly string[];
+  workflow?: string;
+  ref?: string;
+  can: Can;
+}): AccessRule;
+/**
+ * Any OIDC issuer's tokens: GitLab, Buildkite, a cloud's workload identity.
+ * The issuer is pinned here, and only issuers some rule names are trusted or
+ * have their keys fetched. Every listed claim must match exactly (a list is
+ * any of its values), and there must be at least one, since an issuer signs
+ * tokens for everyone it serves. The principal is `oidc:<issuer host and path>:<sub>`,
+ * with any `:` or `%` in the issuer part percent-encoded, so it ends at the first `:`.
+ */
+declare function oidc(options: {
+  issuer: string;
+  claims: Readonly<Record<string, string | readonly string[]>>;
+  can: Can;
+}): AccessRule;
+type IssuerConfig = {
+  /** Accepted `iss` values. */
+  issuer: string | RegExp;
+  /** Key source; defaults to the issuer's published JWKS. */
+  jwks?: JWTVerifyGetKey;
+};
+/** `oidcTokens()`'s options: tests point these at a local issuer; production uses the defaults. */
+type OidcTokensOptions = {
+  vercel?: IssuerConfig;
+  github?: IssuerConfig;
+  /** Keys for `oidc()` issuers, by issuer URL, instead of their published JWKS. It trusts no issuer by itself. */
+  oidc?: Readonly<Record<string, JWTVerifyGetKey>>;
+  /**
+   * A local board's own issuer (`vb serve`): its tokens' `sub` is a person on
+   * this machine, `local:user:<sub>`, with full access. Its keys are never
+   * fetched, so `jwks` is required.
+   */
+  local?: {
+    issuer: string;
+    jwks: JWTVerifyGetKey;
+  };
+};
+/**
+ * What a host's own model gives a principal: what it may do, or null for nothing. It sees only the
+ * principals its own `authenticate` returned.
+ */
+type AccessFunction = (principal: Known) => Can | null | undefined | Promise<Can | null | undefined>;
+/**
+ * A rule of your own, among `vercelProject()` and the rest: what it gives a principal (`'all'`,
+ * `['read']`, `{ 'support/': ['read', 'post'] }`), null for nothing, or undefined to leave it to the
+ * next rule. It's asked whenever a principal acts, a schedule's send included, and never about a
+ * 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'>;
+/**
+ * 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
+ * board's own deployments in the environment it runs in, may do everything. Its scope narrows what
+ * it gets. A 401 or 403 that names the rule that would let it in, when it may do nothing.
+ */
+declare function compileRules(rules: readonly (AccessRule | RuleFunction)[], board: {
+  project(): Promise<{
+    id: string | null;
+    teamId: string | null;
+  }>;
+}): (principal: Known) => Promise<Access>;
+/** What board() knows that verifying a request needs: its own Vercel project, and the OIDC issuers its rules trust. */
+type AuthenticateContext = {
+  /** The board's own Vercel project and team: its people's development tokens are for it. */
+  project(): Promise<{
+    id: string | null;
+    teamId: string | null;
+  }>;
+  /** OIDC issuers past Vercel's and GitHub's whose tokens may be trusted: the ones `oidc()` rules name. */
+  issuers: readonly string[];
+};
+/** What a verifier gets: what the request said, and what the board knows that verifying it needs. */
+type AuthenticateRequest = CallerRequest & {
+  board: AuthenticateContext;
+};
+/**
+ * Who a request is, in the board's ID scheme: `oidcTokens()` checks its bearer token for the
+ * board's URL, and a host's own verifier recognizes its own credentials (a session cookie in
+ * `request.headers`, say). Null when the request carries nothing it recognizes, so verifiers
+ * compose: `(request) => (await staff(request)) ?? (await tokens(request))`. To reject a
+ * credential that fails, throw an `HttpError` (a 401), or return or throw a `Response`; anything
+ * else thrown is a 500. What a principal may do is `board({ access })`'s to say.
+ */
+type Authenticate = (request: AuthenticateRequest) => Principal | HostPrincipal | Response | null | undefined | Promise<Principal | HostPrincipal | Response | null | undefined>;
+/** What a host's own verifier returns: a principal in the board's ID scheme. */
+type HostPrincipal = {
+  /** `vercel:user:<id>`, `vercel:project:<id>:<env>`, …: records keep their shape. */
+  id: string;
+  kind: PrincipalKind;
+  /** Kept as it is: `x-board-handle` doesn't replace it. Return `request.claims.handle` to take the caller's. */
+  handle: string;
+  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 };

package/dist/backend-a2/blob-vercel.d.mts

@@ -0,0 +1,8 @@
+import { t as BlobStore } from "../blob-C0J3wbGv.mjs";
+//#region src/blob/vercel.d.ts
+export declare function vercelBlob(options?: {
+  token?: string;
+  storeId?: string;
+  prefix?: string;
+}): BlobStore;
+//#endregion

package/dist/backend-a2/blob-vercel.mjs

@@ -0,0 +1,81 @@
+import { BlobNotFoundError, get, head, issueSignedToken, presignUrl, put } from "@vercel/blob";
+//#region src/blob/vercel.ts
+/**
+* Attachments in a private Vercel Blob store. Connect one to the board's
+* project; the SDK finds it through `BLOB_READ_WRITE_TOKEN`, or the project's
+* OIDC token and `BLOB_STORE_ID`. Files are private: the board serves them to
+* callers it verified, and the store never hands them out. Direct uploads, for
+* files over 4 MB, `PUT` to a URL the store presigns for one pathname, which
+* takes at most the file's size and never overwrites.
+*/
+/** The Blob API version `@vercel/blob` speaks, which a presigned `PUT` names. */
+const BLOB_API_VERSION = "12";
+function vercelBlob(options = {}) {
+	const auth = {
+		...options.token ? { token: options.token } : {},
+		...options.storeId ? { storeId: options.storeId } : {}
+	};
+	const prefix = options.prefix ? `${options.prefix.replace(/^\/+|\/+$/g, "")}/` : "";
+	return {
+		async put(key, data, contentType) {
+			await put(prefix + key, Buffer.from(data.buffer, data.byteOffset, data.byteLength), {
+				...auth,
+				access: "private",
+				contentType,
+				addRandomSuffix: false
+			});
+		},
+		async get(key) {
+			const found = await get(prefix + key, {
+				...auth,
+				access: "private",
+				...key.endsWith(".json") ? { useCache: false } : {}
+			});
+			if (!found || found.statusCode !== 200) return null;
+			return {
+				data: found.stream,
+				contentType: found.blob.contentType
+			};
+		},
+		async uploadUrl(key, { contentType, maxBytes, expiresAt }) {
+			const pathname = prefix + key;
+			const validUntil = expiresAt.getTime();
+			const signed = await issueSignedToken({
+				...auth,
+				pathname,
+				operations: ["put"],
+				validUntil,
+				allowedContentTypes: [contentType],
+				maximumSizeInBytes: maxBytes
+			});
+			const { presignedUrl } = await presignUrl(signed, {
+				operation: "put",
+				access: "private",
+				pathname,
+				validUntil,
+				allowedContentTypes: [contentType],
+				maximumSizeInBytes: maxBytes,
+				allowOverwrite: false,
+				addRandomSuffix: false
+			});
+			return {
+				url: presignedUrl,
+				headers: {
+					"x-api-version": BLOB_API_VERSION,
+					"x-vercel-blob-access": "private",
+					"x-content-type": contentType
+				}
+			};
+		},
+		async head(key) {
+			try {
+				return { size: (await head(prefix + key, auth)).size };
+			} catch (error) {
+				if (error instanceof BlobNotFoundError) return null;
+				throw error;
+			}
+		}
+	};
+}
+//#endregion
+export { vercelBlob };

package/dist/backend-a2/contract.d.mts

@@ -0,0 +1,18 @@
+import { a as AttachmentId, c as ChannelPath, d as LabelKey, f as LabelValue, g as MessageText, h as MessageId, i as Attachment, l as Emoji, m as MESSAGE_TEXT_MAX, n as ActorId, o as Author, p as Labels, r as ActorKind, s as CHANNEL_PATH_MAX, t as ATTACHMENTS_PER_MESSAGE_MAX, u as Handle } from "../schemas-CWxs3ECJ.mjs";
+import { b as Origin, d as messagesReducer, f as BOARD_SESSION, h as ExternalAuthor, i as ChannelsState, l as actorsReducer, m as BoardEvents, n as ActorsState, o as Message, p as BoardEvent, r as Channel, s as MessagesState, t as Actor, u as channelsReducer, x as boardContract } from "../reducers-B_vUGQRp.mjs";
+//#region src/contract/files.d.ts
+/** Under Vercel Functions' 4.5 MB request body limit, so an upload fits in one request. */
+export declare const ATTACHMENT_BYTES_MAX: number;
+/**
+ * The most a file sync brings over from a platform can be. Sync fetches it on the server and
+ * stores it in-process, so no request carries it and the request limit doesn't apply: this bounds
+ * what one import holds in memory.
+ */
+export declare const IMPORT_BYTES_MAX: number;
+/**
+ * The most a direct upload can be: the client sends the bytes straight to the blob store, on a URL
+ * the board signs, so no request to the board carries them. Needs a store with `uploadUrl`.
+ */
+export declare const DIRECT_UPLOAD_BYTES_MAX: number;
+//#endregion
+export { ATTACHMENTS_PER_MESSAGE_MAX, type Actor, ActorId, ActorKind, type ActorsState, Attachment, AttachmentId, Author, BOARD_SESSION, type BoardEvent, type BoardEvents, CHANNEL_PATH_MAX, type Channel, ChannelPath, type ChannelsState, Emoji, type ExternalAuthor, Handle, LabelKey, LabelValue, Labels, MESSAGE_TEXT_MAX, type Message, MessageId, MessageText, type MessagesState, Origin, actorsReducer, boardContract, channelsReducer, messagesReducer };

package/dist/backend-a2/contract.mjs

@@ -0,0 +1,5 @@
+import { n as DIRECT_UPLOAD_BYTES_MAX, r as IMPORT_BYTES_MAX, t as ATTACHMENT_BYTES_MAX } from "../files-SniSmeEr.mjs";
+import { a as AttachmentId, c as ChannelPath, d as LabelKey, f as LabelValue, g as MessageText, h as MessageId, i as Attachment, l as Emoji, m as MESSAGE_TEXT_MAX, n as ActorId, o as Author, p as Labels, r as ActorKind, s as CHANNEL_PATH_MAX, t as ATTACHMENTS_PER_MESSAGE_MAX, u as Handle } from "../schemas-Be08nyfW.mjs";
+import { f as boardContract, l as Origin, t as BOARD_SESSION } from "../contract-CuJmlrhw.mjs";
+import { d as messagesReducer, n as channelsReducer, t as actorsReducer } from "../reducers-mUPFuFJV.mjs";
+export { ATTACHMENTS_PER_MESSAGE_MAX, ATTACHMENT_BYTES_MAX, ActorId, ActorKind, Attachment, AttachmentId, Author, BOARD_SESSION, CHANNEL_PATH_MAX, ChannelPath, DIRECT_UPLOAD_BYTES_MAX, Emoji, Handle, IMPORT_BYTES_MAX, LabelKey, LabelValue, Labels, MESSAGE_TEXT_MAX, MessageId, MessageText, Origin, actorsReducer, boardContract, channelsReducer, messagesReducer };

package/dist/backend-a2/scheduler-local.d.mts

@@ -0,0 +1,11 @@
+import { A2Scheduler } from "experimental-a2/server";
+//#region src/scheduler/local.d.ts
+/**
+ * A scheduler in this process (`@vercel/board/backend-a2/scheduler-local`): each task runs at its time on
+ * a timer, so retries, leases, wake-ups, and scheduled messages work with nothing else running.
+ * Its timers live in the process, and a restart drops the pending ones, so it's for development,
+ * `vb serve`, tests, and long-running servers, never serverless functions, which stop between
+ * requests: there, use `vercelQueues()` or `qstash()`.
+ */
+export declare function localScheduler(): A2Scheduler;
+//#endregion

package/dist/backend-a2/scheduler-local.mjs

@@ -0,0 +1,2 @@
+import { t as localScheduler } from "../local-Cr_dSjvs.mjs";
+export { localScheduler };

package/dist/backend-a2/scheduler-qstash.d.mts

@@ -0,0 +1,2 @@
+import { QStashSchedulerOptions, qstash } from "experimental-a2/scheduler-qstash";
+export { type QStashSchedulerOptions, qstash };

package/dist/backend-a2/scheduler-qstash.mjs

@@ -0,0 +1,2 @@
+import { qstash } from "experimental-a2/scheduler-qstash";
+export { qstash };

package/dist/backend-a2/scheduler-vercel.d.mts

@@ -0,0 +1,2 @@
+import { VercelQueuesOptions, vercelQueues } from "experimental-a2/scheduler-vercel";
+export { type VercelQueuesOptions, vercelQueues };

package/dist/backend-a2/scheduler-vercel.mjs

@@ -0,0 +1,2 @@
+import { vercelQueues } from "experimental-a2/scheduler-vercel";
+export { vercelQueues };

package/dist/backend-a2/store-memory.d.mts

@@ -0,0 +1,11 @@
+import { t as BoardStore } from "../types-BHCjTZdB.mjs";
+import { Clock } from "experimental-a2/server";
+//#region src/store/memory.d.ts
+/**
+ * A board that lives in memory, for tests: its log in A2's memory store, its
+ * tables in an in-memory SQLite. `clock` sets every stored timestamp.
+ */
+export declare function memory(options?: {
+  clock?: Clock;
+}): BoardStore;
+//#endregion

package/dist/backend-a2/store-memory.mjs

@@ -0,0 +1,19 @@
+import { r as sqlTables } from "../sql-DbiEnqM0.mjs";
+import { t as sqliteDb } from "../sqlite-db-Cbj03vmp.mjs";
+import { memory as memory$1 } from "experimental-a2/store-memory";
+//#region src/store/memory.ts
+/**
+* A board that lives in memory, for tests: its log in A2's memory store, its
+* tables in an in-memory SQLite. `clock` sets every stored timestamp.
+*/
+function memory(options = {}) {
+	const log = memory$1(options.clock ? { clock: options.clock } : {});
+	const tables = sqlTables(sqliteDb(":memory:"));
+	return {
+		log,
+		tables,
+		close: () => tables.close()
+	};
+}
+//#endregion
+export { memory };