permdock 0.3.1 → 0.5.0

package/dist/evaluations-16UqqQ6W.d.ts

@@ -0,0 +1,32 @@
+import { T as Policy } from "./policy-types-DzwivBgR.js";
+import { r as PermDock } from "./permdock-D7eeLJER.js";
+import { m as ApprovalStore } from "./types-CCpc2Dcv.js";
+//#region src/server/evaluations.d.ts
+/** AuthZEN 1.0 section 7.1.2.1 `options.evaluations_semantic` values. */
+declare const EVALUATIONS_SEMANTICS: readonly ["execute_all", "deny_on_first_deny", "permit_on_first_permit"];
+type EvaluationsSemantic = (typeof EVALUATIONS_SEMANTICS)[number];
+/** The batch's `evaluations_semantic`: `execute_all` when absent, `undefined` for an unknown value. */
+declare function evaluationsSemantic(body: Readonly<Record<string, unknown>>): EvaluationsSemantic | undefined;
+/**
+ * Evaluates `items` under `semantic`: all at once for `execute_all`, else in
+ * order, stopping after the first deny or permit.
+ */
+declare function evaluateBatch<T extends {
+  readonly decision: boolean;
+}>(items: readonly unknown[], semantic: EvaluationsSemantic, rowOf: (item: unknown) => Promise<T>): Promise<T[]>;
+declare function evaluationsHandler(options: {
+  readonly policy: Policy;
+  readonly resolve?: (request: Request) => Promise<PermDock>;
+  readonly getPermDock?: (query?: {
+    readonly tenant?: string;
+  }) => Promise<PermDock>;
+  readonly store?: ApprovalStore;
+  readonly adapter?: string;
+  /** The most evaluations one POST may carry; a larger batch is a 413 before any instance is resolved. */
+  readonly maxEvaluations?: number;
+}): {
+  readonly POST: (request: Request) => Promise<Response>;
+  readonly GET: (request: Request) => Promise<Response>;
+};
+//#endregion
+export { evaluationsSemantic as a, evaluationsHandler as i, EvaluationsSemantic as n, evaluateBatch as r, EVALUATIONS_SEMANTICS as t };

package/dist/{evaluations-tz6D9A2G.js → evaluations-DZ2CbV5k.js}

@@ -1,11 +1,14 @@
-import { t as compact } from "./compact-y6vfu2_f.js";
-import { t as PROBLEM_BASE } from "./validation-error-CnjZ4t92.js";
-import { a as wireDenials } from "./problem-details-_AMOYz-w.js";
+import { r as isRecord, t as compact } from "./compact-CAf557ZB.js";
+import { t as PROBLEM_BASE } from "./validation-error-ZfUHbKvf.js";
+import { t as wireDenials } from "./wire-denial-C7PaVYEM.js";
+import { c as listPermissions, g as formerScopes, h as formerKeys } from "./permission-registry-Br4jSNVi.js";
+import { h as secondsAt } from "./time-DkWjdL98.js";
 import { n as resourceRef } from "./resource-ref-CaS9yVPi.js";
-import { s as problemResponse, t as batchTooLarge, u as validationProblem } from "./problem-B43ztKIm.js";
-import { i as readApprovalHeader, s as resumeDecision } from "./helpers-H_KARDVC.js";
+import { n as readBodyText } from "./body-text-QcXok_SI.js";
+import { c as problemResponse, d as validationProblem, n as batchTooLarge } from "./problem-CTviyH5L.js";
+import { i as readApprovalHeader, s as resumeDecision } from "./helpers-DTcZOzhF.js";
+import { t as bodyTooLarge } from "./body-CH5of8Ne.js";
 import { t as timeoutSignal } from "./timeout-D51niuQP.js";
-import { n as permissionLookup, t as itemResourceData } from "./evaluation-items-CfCCejQd.js";
 //#region src/core/decision.ts
 /** The denial for a check that failed or named no declared permission. */
 const NO_GRANT = Object.freeze({
@@ -17,12 +20,59 @@ const NO_GRANT = Object.freeze({
 	alternatives: Object.freeze([])
 });
 //#endregion
+//#region src/server/evaluation-items.ts
+function firstWins(map, name, leaf) {
+	if (!map.has(name)) map.set(name, leaf);
+}
+/**
+* Indexes `tree` once. The lookup tries `action` as a permission key or
+* scope, then `<resource.type>.<action>`, then the leaf with that resource
+* and action; current names win over former ones and earlier leaves over
+* later ones. Anything else is `undefined`, which the caller denies.
+*/
+function permissionLookup(tree) {
+	const current = /* @__PURE__ */ new Map();
+	const former = /* @__PURE__ */ new Map();
+	const byPair = /* @__PURE__ */ new Map();
+	for (const leaf of listPermissions(tree)) {
+		firstWins(current, leaf.key, leaf);
+		firstWins(current, leaf.scope, leaf);
+		for (const name of [...formerKeys(leaf), ...formerScopes(leaf)]) firstWins(former, name, leaf);
+		firstWins(byPair, `${leaf.resource}\u0000${leaf.action}`, leaf);
+	}
+	const named = (name) => current.get(name) ?? former.get(name);
+	return (action, resource) => {
+		if (action === void 0) return;
+		const byKey = named(action);
+		if (byKey !== void 0) return byKey;
+		const type = typeof resource?.type === "string" ? resource.type : void 0;
+		if (type === void 0) return;
+		return named(`${type}.${action}`) ?? byPair.get(`${type}\u0000${action}`);
+	};
+}
+/** AuthZEN's sentinel resource id for a collection: the type as a whole, no row. */
+const COLLECTION_ID = "*";
+/** A resource id as a row id: `undefined` for none, a non-scalar or the collection sentinel `*`. */
+function wireResourceId(id) {
+	if (typeof id !== "string" && typeof id !== "number") return;
+	const text = String(id);
+	return text === COLLECTION_ID ? void 0 : text;
+}
+/** The row an item's resource describes: its `properties`, else `{ id }`, else none for `id: "*"`. */
+function itemResourceData(resource) {
+	const properties = resource?.properties;
+	if (properties !== null && typeof properties === "object") return properties;
+	const id = wireResourceId(resource?.id);
+	return id === void 0 ? void 0 : { id };
+}
+//#endregion
 //#region src/server/web-bot-auth.ts
 /** Milliseconds a key directory fetch may take before the signature counts as unverifiable. */
 const DIRECTORY_TIMEOUT_MS = 5e3;
 const DEFAULT_MAX_AGE = 300;
 const FUTURE_SKEW = 60;
 const DIRECTORY_PATH = "/.well-known/http-message-signatures-directory";
+const WEB_BOT_AUTH_TAG = "web-bot-auth";
 var InvalidSignatureError = class extends Error {
 	name = "InvalidSignatureError";
 	response;
@@ -72,7 +122,18 @@ function discoverViaSignatureAgent(options) {
 	};
 	return { lookup };
 }
-async function verifyWebBotAuth(request, options) {
+/**
+* Verifies Web Bot Auth requests: an RFC 9421 signature tagged `web-bot-auth`
+* that covers `@authority`, and `signature-agent` when the request sends
+* `Signature-Agent` (draft-meunier-webbotauth-httpsig-protocol).
+*/
+function webBotAuthVerifier(options) {
+	return Object.freeze({
+		name: "web-bot-auth",
+		verify: (request) => verifySignature(request, options, true)
+	});
+}
+async function verifySignature(request, options, profile) {
 	if (options === void 0 || options.verify === false) return;
 	const signatureInput = request.headers.get("Signature-Input");
 	if (signatureInput === null) {
@@ -84,13 +145,15 @@ async function verifyWebBotAuth(request, options) {
 	if (parsed === void 0 || signatureHeader === null) throw reject("Signature-Input could not be parsed");
 	const signature = parseSignature(signatureHeader, parsed.label);
 	if (signature === void 0) throw reject("Signature could not be parsed");
-	const now = options.now?.() ?? Math.floor(Date.now() / 1e3);
+	const now = secondsAt(options.now?.());
 	const maxAge = options.maxAge ?? DEFAULT_MAX_AGE;
 	if (typeof parsed.created !== "number") throw reject("Signature-Input created is required");
 	if (parsed.created > now + FUTURE_SKEW) throw reject("Signature-Input created is in the future");
 	if (now - parsed.created > maxAge) throw reject("Signature-Input created is too old");
 	if (typeof parsed.expires === "number" && parsed.expires < now) throw reject("Signature-Input expires is in the past");
 	if (parsed.keyid === void 0) throw reject("Signature-Input keyid is required");
+	const violation = profile ? profileViolation(request, parsed) : void 0;
+	if (violation !== void 0) throw reject(violation);
 	const agent = parseSignatureAgent(request.headers.get("Signature-Agent"), parsed.label);
 	const lookup = typeof options.keys === "function" ? options.keys : options.keys.lookup;
 	let key;
@@ -114,6 +177,11 @@ async function verifyWebBotAuth(request, options) {
 		kind: "web-bot-auth"
 	});
 }
+function profileViolation(request, parsed) {
+	if (parsed.tag !== WEB_BOT_AUTH_TAG) return `Signature-Input tag must be "${WEB_BOT_AUTH_TAG}"`;
+	if (!parsed.components.includes("@authority")) return "Signature-Input must cover @authority";
+	if (request.headers.has("Signature-Agent") && !parsed.components.includes("signature-agent")) return "Signature-Input must cover signature-agent";
+}
 function reject(detail) {
 	return new InvalidSignatureError(invalidSignatureProblem(detail));
 }
@@ -129,6 +197,7 @@ function parseSignatureInput(header) {
 		expires: inner.expires,
 		keyid: inner.keyid,
 		alg: inner.alg,
+		tag: inner.tag,
 		innerListAndParams: member.value.trim()
 	});
 }
@@ -175,7 +244,8 @@ function parseInnerListAndParams(value) {
 		created: asUnix(params["created"]),
 		expires: asUnix(params["expires"]),
 		keyid: typeof params["keyid"] === "string" ? params["keyid"] : void 0,
-		alg: typeof params["alg"] === "string" ? params["alg"] : void 0
+		alg: typeof params["alg"] === "string" ? params["alg"] : void 0,
+		tag: typeof params["tag"] === "string" ? params["tag"] : void 0
 	});
 }
 function parseQuotedList(inner) {
@@ -329,10 +399,83 @@ function decodeSfBytes(value) {
 }
 //#endregion
 //#region src/server/evaluations.ts
+/** AuthZEN 1.0 section 7.1.2.1 `options.evaluations_semantic` values. */
+const EVALUATIONS_SEMANTICS = [
+	"execute_all",
+	"deny_on_first_deny",
+	"permit_on_first_permit"
+];
+/** The batch's `evaluations_semantic`: `execute_all` when absent, `undefined` for an unknown value. */
+function evaluationsSemantic(body) {
+	const options = body["options"];
+	const value = isRecord(options) ? options["evaluations_semantic"] : void 0;
+	if (value === void 0) return "execute_all";
+	return EVALUATIONS_SEMANTICS.find((semantic) => semantic === value);
+}
+function unknownSemanticProblem() {
+	return validationProblem(`options.evaluations_semantic must be one of ${EVALUATIONS_SEMANTICS.join(", ")}`);
+}
+/**
+* Evaluates `items` under `semantic`: all at once for `execute_all`, else in
+* order, stopping after the first deny or permit.
+*/
+async function evaluateBatch(items, semantic, rowOf) {
+	if (semantic === "execute_all") return Promise.all(items.map(rowOf));
+	const stopOn = semantic === "permit_on_first_permit";
+	const rows = [];
+	for (const item of items) {
+		const row = await rowOf(item);
+		rows.push(row);
+		if (row.decision === stopOn) break;
+	}
+	return rows;
+}
+/** AuthZEN 1.0 section 10.1.1: a response echoes the request's `X-Request-ID`. */
+function withRequestId(request, response) {
+	const id = request.headers.get("x-request-id");
+	if (id === null || id === "") return response;
+	const headers = new Headers(response.headers);
+	headers.set("X-Request-ID", id);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+/** AuthZEN 1.0 section 9.1 PDP metadata for the PDP at `pdp`. */
+function authzenMetadata(pdp, search = {}) {
+	return compact({
+		policy_decision_point: pdp,
+		access_evaluation_endpoint: `${pdp}/access/v1/evaluation`,
+		access_evaluations_endpoint: `${pdp}/access/v1/evaluations`,
+		search_subject_endpoint: search.subject === true ? `${pdp}/access/v1/search/subject` : void 0,
+		search_resource_endpoint: search.resource === true ? `${pdp}/access/v1/search/resource` : void 0,
+		search_action_endpoint: search.action === true ? `${pdp}/access/v1/search/action` : void 0
+	});
+}
+/**
+* `reason_admin` and `reason_user` for a decision that is not granted, from
+* the denial roles and reasons the context already carries. The user reason
+* names no role, grant or subject.
+*/
+function evaluationReasons(decision, permission) {
+	switch (decision.outcome) {
+		case "granted": return {};
+		case "denied": return {
+			reason_admin: { en: `${permission} denied: ${decision.denials.map((denial) => `${denial.role ?? "none"} (${denial.reason})`).join(", ")}.` },
+			reason_user: { en: `${permission} is not permitted.` }
+		};
+		case "approval-required": return {
+			reason_admin: { en: `${permission} requires human approval (${decision.reason}).` },
+			reason_user: { en: `${permission} requires approval.` }
+		};
+		default: return decision;
+	}
+}
 function permissionOf(lookup, item) {
 	return lookup(typeof item.action?.name === "string" ? item.action.name : void 0, item.resource);
 }
-function evaluationRow(decision) {
+function evaluationRow(decision, permission) {
 	switch (decision.outcome) {
 		case "granted": return {
 			decision: true,
@@ -348,14 +491,16 @@ function evaluationRow(decision) {
 				permdock: {
 					...decision,
 					denials: wireDenials(decision.denials)
-				}
+				},
+				...evaluationReasons(decision, permission)
 			}
 		};
 		case "approval-required": return {
 			decision: false,
 			context: {
 				outcome: "approval-required",
-				permdock: decision
+				permdock: decision,
+				...evaluationReasons(decision, permission)
 			}
 		};
 		default: return decision;
@@ -374,11 +519,14 @@ function applyApprovalResume(decision, permission, permdock, store, request, res
 }
 function evaluateOne(lookup, permdock, item, store, header, adapter) {
 	const permission = permissionOf(lookup, item);
-	if (permission === void 0) return Promise.resolve(NO_GRANT);
+	if (permission === void 0) return Promise.resolve({
+		decision: NO_GRANT,
+		permission: typeof item.action?.name === "string" ? item.action.name : "unknown"
+	});
 	const data = itemResourceData(item.resource);
 	const decide = permdock.decide;
 	const decision = decide(permission, data, compact({
-		source: "endpoint",
+		call: "endpoint",
 		adapter,
 		trusted: false,
 		boundary: "decision-endpoint"
@@ -388,11 +536,14 @@ function evaluateOne(lookup, permdock, item, store, header, adapter) {
 		permission,
 		subject: permdock.subject,
 		store,
-		resource: resourceRef(permission, data, item.resource?.id),
+		resource: resourceRef(permission, data, wireResourceId(item.resource?.id)),
 		adapter,
 		token: header,
 		consume: false
-	});
+	}).then((resumed) => ({
+		decision: resumed,
+		permission: permission.key
+	}));
 }
 async function resolvePermdock(options, request, tenant) {
 	if (options.resolve !== void 0) {
@@ -402,14 +553,16 @@ async function resolvePermdock(options, request, tenant) {
 	if (options.getPermDock !== void 0) return options.getPermDock(tenant === void 0 ? void 0 : { tenant });
 	throw new TypeError("evaluations handler needs resolve or getPermDock");
 }
-function createEvaluationsHandler(options) {
+function evaluationsHandler(options) {
 	const adapter = options.adapter ?? "server";
 	const lookup = permissionLookup(options.policy.permissions);
 	const maxEvaluations = options.maxEvaluations ?? 256;
 	const POST = async (request) => {
+		const read = await readBodyText(request);
+		if (!read.ok) return read.cause === "too-large" ? bodyTooLarge() : validationProblem("evaluations body was not valid JSON");
 		let body;
 		try {
-			body = await request.json();
+			body = JSON.parse(read.text);
 		} catch {
 			return validationProblem("evaluations body was not valid JSON");
 		}
@@ -418,6 +571,8 @@ function createEvaluationsHandler(options) {
 		if (evaluations === void 0) return validationProblem("evaluations array is required");
 		if (!Array.isArray(evaluations)) return validationProblem("evaluations must be an array");
 		if (evaluations.length > maxEvaluations) return batchTooLarge(maxEvaluations);
+		const semantic = evaluationsSemantic(body);
+		if (semantic === void 0) return unknownSemanticProblem();
 		const header = readApprovalHeader(request.headers);
 		let permdock;
 		try {
@@ -426,21 +581,15 @@ function createEvaluationsHandler(options) {
 			if (error instanceof InvalidSignatureError) return error.response;
 			throw error;
 		}
-		const rows = await Promise.all(evaluations.map(async (item) => {
-			return evaluationRow(await evaluateOne(lookup, permdock, item !== null && typeof item === "object" ? item : {}, options.store, header, adapter));
-		}));
+		const rows = await evaluateBatch(evaluations, semantic, async (item) => {
+			const evaluated = await evaluateOne(lookup, permdock, item !== null && typeof item === "object" ? item : {}, options.store, header, adapter);
+			return evaluationRow(evaluated.decision, evaluated.permission);
+		});
 		return Response.json({ evaluations: rows });
 	};
 	const GET = async (request) => {
 		const url = new URL(request.url);
-		if (url.pathname.includes("authzen-configuration")) {
-			const origin = url.origin;
-			return Response.json({
-				policy_decision_point: origin,
-				access_evaluation_endpoint: `${origin}/access/v1/evaluation`,
-				access_evaluations_endpoint: `${origin}/access/v1/evaluations`
-			});
-		}
+		if (url.pathname.includes("authzen-configuration")) return Response.json(authzenMetadata(url.origin));
 		const tenant = url.searchParams.get("tenant") ?? void 0;
 		let permdock;
 		try {
@@ -453,9 +602,9 @@ function createEvaluationsHandler(options) {
 		return Response.json(await Promise.resolve(snapshot));
 	};
 	return {
-		POST,
-		GET
+		POST: async (request) => withRequestId(request, await POST(request)),
+		GET: async (request) => withRequestId(request, await GET(request))
 	};
 }
 //#endregion
-export { invalidSignatureProblem as a, NO_GRANT as c, discoverViaSignatureAgent as i, createEvaluationsHandler as n, invalidSignatureResponse as o, InvalidSignatureError as r, verifyWebBotAuth as s, applyApprovalResume as t };
+export { wireResourceId as _, evaluationReasons as a, unknownSemanticProblem as c, discoverViaSignatureAgent as d, invalidSignatureProblem as f, permissionLookup as g, itemResourceData as h, evaluateBatch as i, withRequestId as l, webBotAuthVerifier as m, applyApprovalResume as n, evaluationsHandler as o, invalidSignatureResponse as p, authzenMetadata as r, evaluationsSemantic as s, EVALUATIONS_SEMANTICS as t, InvalidSignatureError as u, NO_GRANT as v };

package/dist/eve/index.d.ts

@@ -1,8 +1,8 @@
-import { C as Policy, D as PolicyVocabulary, Nr as Principal, kr as Delegation, ln as PermDock } from "../policy-IB6yxpC3.js";
-import { f as Permission } from "../permissions-DttnqqxC.js";
-import { c as ApprovalRequest, f as ApprovalStore } from "../types-aqOHTHcp.js";
-import { t as InstanceOptions } from "../instance-options-jARdwfPN.js";
-import { t as ToolMap } from "../types-Bvc4oWT6.js";
+import { T as Policy, j as PolicyVocabulary, rr as Principal } from "../policy-types-DzwivBgR.js";
+import { w as Permission } from "../vocabulary-D6lPdb4Z.js";
+import { r as PermDock } from "../permdock-D7eeLJER.js";
+import { u as ApprovalRequest } from "../types-CCpc2Dcv.js";
+import { o as AgentAdapterOptions, t as AgentPermDock } from "../create-BDS7wc3y.js";
 //#region src/eve/create.d.ts
 /** Structural `SessionAuthContext` from `eve`. */
 type EvePrincipal = {
@@ -49,14 +49,10 @@ type EveContext = Pick<EveApprovalContext, "session" | "callId">;
 type EveApprovers = {
   readonly roles: readonly string[];
 } | ((responder: EvePrincipal, request: ApprovalRequest) => boolean);
-type EvePermDockOptions<TUser = unknown> = InstanceOptions & {
+type EvePermDockOptions<TUser = unknown> = Omit<AgentAdapterOptions<EveContext, TUser>, "subject"> & {
+  /** Defaults to `subjectFromEve`: the session initiator's id and `roles` attribute. */
   readonly subject?: (context: EveContext) => TUser | Promise<TUser>;
-  readonly actor?: (context: EveContext) => unknown;
-  readonly delegation?: (context: EveContext) => Delegation | undefined | Promise<Delegation | undefined>;
-  readonly tenant?: string | ((context: EveContext) => string | undefined | Promise<string | undefined>);
-  readonly tools: ToolMap;
   readonly approvers?: EveApprovers;
-  readonly store?: ApprovalStore;
 };
 type EveRequestResult = "not-applicable" | "user-approval" | {
   readonly type: "denied";
@@ -73,14 +69,14 @@ type EveApprovalPair = {
   readonly request: (ctx: EveApprovalContext) => Promise<EveRequestResult>;
   readonly response: (ctx: EveResponseContext) => Promise<EveResponseResult>;
 };
-type EvePermDock<V extends PolicyVocabulary = PolicyVocabulary> = {
+type EvePermDock<V extends PolicyVocabulary = PolicyVocabulary> = AgentPermDock<EveContext, V> & {
   readonly approval: EveApprovalPair;
   readonly approvalFor: (permission: Permission, data?: (input: unknown) => unknown) => EveApprovalPair;
-  readonly permdock: (ctx: EveContext) => Promise<PermDock<V>>;
+  readonly getPermDock: (ctx: EveContext) => Promise<PermDock<V>>;
 };
 export declare function rolesOf(principal: EvePrincipal | null | undefined): string[];
-export declare function subjectFromSession(context: EveContext): unknown;
-export declare function actorFromSession(context: EveContext): unknown;
-export declare function createPermDock<TUser, TPrincipal extends Principal = Principal, V extends PolicyVocabulary = PolicyVocabulary>(policy: Policy<TUser, TPrincipal, V>, options: EvePermDockOptions<TUser>): EvePermDock<V>;
+export declare function subjectFromEve(context: EveContext): unknown;
+export declare function actorFromEve(context: EveContext): unknown;
+export declare function createPermDock<TUser, TPrincipal extends Principal = Principal, V extends PolicyVocabulary = PolicyVocabulary>(policy: Policy<TUser, TPrincipal, V>, given: EvePermDockOptions<TUser>): EvePermDock<V>;
 //#endregion
 export type { EveApprovalContext, EveApprovalPair, EveApprovers, EveContext, EvePermDock, EvePermDockOptions, EvePrincipal, EveRequestResult, EveResponseContext, EveResponseResult };

package/dist/eve/index.js

@@ -1,9 +1,8 @@
-import { t as compact } from "../compact-y6vfu2_f.js";
-import { n as isApprovalError } from "../errors-DRnGZHzF.js";
-import { r as memoryApprovalStore } from "../store-DMAWwAJV.js";
-import { o as resolveApproval } from "../helpers-H_KARDVC.js";
-import { t as instanceOptions } from "../instance-options-Dhhcnm3y.js";
-import { n as createAgentKernel } from "../kernel-_RRHmnMY.js";
+import { t as compact } from "../compact-CAf557ZB.js";
+import { c as withApp } from "../permdock-B9JxkBwC.js";
+import { c as isApprovalError } from "../types-DqzsnlSA.js";
+import { o as resolveApproval } from "../helpers-DTcZOzhF.js";
+import { t as agentRuntime } from "../create-C3b4B5eF.js";
 import { t as boundedMap } from "../lru-8q4WZjBV.js";
 //#region src/eve/create.ts
 const TOKENS_PER_PROCESS = 1e3;
@@ -13,7 +12,7 @@ function rolesOf(principal) {
 	if (!Array.isArray(roles)) return [];
 	return roles.filter((role) => typeof role === "string");
 }
-function subjectFromSession(context) {
+function subjectFromEve(context) {
 	const initiator = context.session?.auth?.initiator;
 	if (initiator === void 0 || initiator === null) return null;
 	return {
@@ -21,7 +20,7 @@ function subjectFromSession(context) {
 		roles: rolesOf(initiator)
 	};
 }
-function actorFromSession(context) {
+function actorFromEve(context) {
 	const auth = context.session?.auth;
 	const initiator = auth?.initiator;
 	const current = auth?.current;
@@ -51,21 +50,15 @@ function mayApprove(approvers, responder, request) {
 function callKey(sessionId, callId) {
 	return JSON.stringify([sessionId ?? null, callId]);
 }
-function createPermDock(policy, options) {
-	const store = options.store ?? memoryApprovalStore();
+function createPermDock(policy, given) {
+	const options = withApp(policy, given);
+	const store = options.store;
 	const tokensByCall = boundedMap(TOKENS_PER_PROCESS);
-	const kernel = createAgentKernel(policy, {
-		...compact({
-			tenant: options.tenant,
-			delegation: options.delegation
-		}),
-		...instanceOptions(options),
-		subject: options.subject ?? subjectFromSession,
-		actor: options.actor ?? actorFromSession,
-		tools: options.tools,
-		store,
-		adapter: "eve"
-	});
+	const { agent, kernel } = agentRuntime(policy, {
+		...options,
+		subject: options.subject ?? subjectFromEve,
+		actor: options.actor ?? actorFromEve
+	}, "eve");
 	const approverOf = async (responder, sessionId) => {
 		try {
 			return (await kernel.instance({ session: {
@@ -82,6 +75,7 @@ function createPermDock(policy, options) {
 	const pairFor = (bindingFor) => {
 		const request = async (ctx) => {
 			const binding = bindingFor(ctx.toolName);
+			if (binding === void 0 && options.unmapped === "allow") return "not-applicable";
 			const verdict = binding === void 0 ? await kernel.decideTool(ctx.toolName, ctx.toolInput, ctx) : await kernel.evaluate(binding, ctx.toolName, ctx.toolInput, ctx, { denyPending: true });
 			if (verdict.outcome === "approval-required" && ctx.callId !== void 0) tokensByCall.set(callKey(ctx.session?.id, ctx.callId), verdict.token);
 			return mapVerdict(verdict);
@@ -105,7 +99,7 @@ function createPermDock(policy, options) {
 		};
 		const response = async (ctx) => {
 			const token = await tokenOf(ctx);
-			if (token === void 0) return {
+			if (token === void 0 || store === void 0) return {
 				status: "rejected",
 				reason: "approval-not-found"
 			};
@@ -158,7 +152,7 @@ function createPermDock(policy, options) {
 			response
 		};
 	};
-	const approval = pairFor((toolName) => Object.hasOwn(options.tools, toolName) ? options.tools[toolName] : void 0);
+	const approval = pairFor((toolName) => Object.hasOwn(options.operations, toolName) ? options.operations[toolName] : void 0);
 	const approvalFor = (permission, data) => {
 		const binding = compact({
 			permission,
@@ -166,11 +160,11 @@ function createPermDock(policy, options) {
 		});
 		return pairFor(() => binding);
 	};
-	return {
+	return Object.freeze({
+		...agent,
 		approval,
-		approvalFor,
-		permdock: (ctx) => kernel.instance(ctx)
-	};
+		approvalFor
+	});
 }
 //#endregion
-export { actorFromSession, createPermDock, rolesOf, subjectFromSession };
+export { actorFromEve, createPermDock, rolesOf, subjectFromEve };

package/dist/event-time-CsegxXxB.js

@@ -0,0 +1,23 @@
+import { l as isRfc3339, u as isoAt } from "./time-DkWjdL98.js";
+//#region src/core/event-time.ts
+const MAX_TIME_VALUE = 864e13;
+/**
+* An event time as RFC 3339, or `undefined` when there is none or it is not a
+* time: NumericDate seconds are converted and an RFC 3339 string passes through.
+* Never throws, so a decision event never fails on a malformed expiry.
+*/
+function eventInstant(value) {
+	if (typeof value === "string") return isRfc3339(value) ? value : void 0;
+	if (typeof value !== "number") return;
+	const millis = value * 1e3;
+	return Math.abs(millis) <= MAX_TIME_VALUE ? isoAt(millis) : void 0;
+}
+/** `eventInstant` for a builder input, where a malformed time is the caller's error. */
+function requireEventInstant(value, field) {
+	if (value === void 0) return;
+	const instant = eventInstant(value);
+	if (instant === void 0) throw new RangeError(`PermDock: ${field} is not an RFC 3339 instant`);
+	return instant;
+}
+//#endregion
+export { requireEventInstant as n, eventInstant as t };

package/dist/expiry-D4_YKRKD.js

@@ -0,0 +1,52 @@
+import { c as instantOf } from "./time-DkWjdL98.js";
+//#region src/core/ids.ts
+/**
+* The canonical text of a scope or object id: a non-empty string as is, a
+* finite number or a bigint as its decimal text (a `bigint` key column read
+* through supabase-js arrives as a number), anything else none.
+*/
+function idText(value) {
+	if (typeof value === "string") return value === "" ? void 0 : value;
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (typeof value === "bigint") return String(value);
+}
+const MAX_ID = 256;
+const MAX_ENTRIES = 64;
+/** A wire id: a non-empty string of at most 256 characters. */
+function isId(value) {
+	return typeof value === "string" && value.length > 0 && value.length <= MAX_ID;
+}
+/** A non-empty list of at most 64 wire ids, deduplicated, else `undefined`. */
+function idList(value) {
+	if (!Array.isArray(value) || value.length === 0 || value.length > MAX_ENTRIES || !value.every(isId)) return;
+	return [...new Set(value)];
+}
+/** Whether two ids are the same id once both are read as text; a missing id matches nothing. */
+function sameId(left, right) {
+	const text = idText(left);
+	return text !== void 0 && text === idText(right);
+}
+//#endregion
+//#region src/core/expiry.ts
+/**
+* `expiresAt` is Unix seconds; a membership with none never expires. One that
+* is not a number below infinity (`NaN`) has already expired: fail closed.
+*/
+function expiredAt(item, now) {
+	return item.expiresAt !== void 0 && !(item.expiresAt > now);
+}
+/**
+* Unix seconds of a stored expiry: finite Unix seconds, an RFC 3339 string
+* (the Postgres `timestamptz` JSON form), a `Date` or an `Instant`.
+* `undefined` for anything else, which the caller treats as already expired.
+*/
+function expirySeconds(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (value instanceof Date) {
+		const millis = value.getTime();
+		return Number.isFinite(millis) ? Math.floor(millis / 1e3) : void 0;
+	}
+	return instantOf(value);
+}
+//#endregion
+export { isId as a, idText as i, expirySeconds as n, sameId as o, idList as r, expiredAt as t };

package/dist/express/index.d.ts

@@ -1,23 +1,26 @@
-import { C as Policy, D as PolicyVocabulary, Nr as Principal, ln as PermDock } from "../policy-IB6yxpC3.js";
-import { f as Permission } from "../permissions-DttnqqxC.js";
-import { h as InvalidSignatureError, i as ProtectOptions, n as OpenApiHooks, w as verifyWebBotAuth, x as discoverViaSignatureAgent } from "../create-B1d519XK.js";
-import { t as ServerAdapterOptions } from "../bind-C_ob3LKa.js";
-import { a as toRequest, i as sendResponse } from "../http-DPuDaChb.js";
+import { T as Policy, j as PolicyVocabulary, rr as Principal } from "../policy-types-DzwivBgR.js";
+import { w as Permission } from "../vocabulary-D6lPdb4Z.js";
+import { r as PermDock } from "../permdock-D7eeLJER.js";
+import { f as InvalidSignatureError, i as OpenApiHooks, o as ProtectOptions, v as discoverViaSignatureAgent, x as webBotAuthVerifier } from "../server-types-BLd4MnBX.js";
+import { t as ServerAdapterOptions } from "../bind--9EFVYWF.js";
+import { i as toRequest, r as sendResponse } from "../http-B_LphE5Y.js";
 import { ErrorRequestHandler, Request, RequestHandler, Response, Router } from "express";
 //#region src/express/create.d.ts
 type ExpressPermDockOptions<TUser = unknown> = ServerAdapterOptions<Request, TUser>;
-type PermDockRequest<T = unknown, V extends PolicyVocabulary = PolicyVocabulary> = Request & {
+type ExpressPermDockRequest<T = unknown, V extends PolicyVocabulary = PolicyVocabulary> = Request & {
   permdock: PermDock<V>;
   permdockData?: T;
 };
 type ExpressPermDock<V extends PolicyVocabulary = PolicyVocabulary> = {
-  readonly permdock: () => RequestHandler;
-  readonly protect: (permission: Permission | null, loadData?: (req: Request) => unknown, protectOptions?: ProtectOptions) => RequestHandler;
+  /** The `PermDock` for one request, for code the middleware does not run before. */
+  readonly getPermDock: (req: Request) => Promise<PermDock<V>>;
+  readonly middleware: () => RequestHandler;
+  readonly protect: (permission: Permission | null, data?: (req: Request) => unknown, protectOptions?: ProtectOptions) => RequestHandler;
   readonly errorHandler: () => ErrorRequestHandler;
   readonly permdockHandler: () => Router;
-  readonly withPermDock: (fn: (req: PermDockRequest<unknown, V>, res: Response) => unknown) => RequestHandler;
+  readonly withPermDock: (fn: (req: ExpressPermDockRequest<unknown, V>, res: Response) => unknown) => RequestHandler;
   readonly openapi: OpenApiHooks;
 };
 export declare function createPermDock<TUser, TPrincipal extends Principal = Principal, V extends PolicyVocabulary = PolicyVocabulary>(policy: Policy<TUser, TPrincipal, V>, options: ExpressPermDockOptions<TUser>): ExpressPermDock<V>;
 //#endregion
-export { type ExpressPermDock, type ExpressPermDockOptions, InvalidSignatureError, type PermDockRequest, discoverViaSignatureAgent, sendResponse, toRequest, verifyWebBotAuth };
+export { type ExpressPermDock, type ExpressPermDockOptions, type ExpressPermDockRequest, InvalidSignatureError, discoverViaSignatureAgent, sendResponse, toRequest, webBotAuthVerifier };