permdock 0.0.0 → 0.1.0

package/dist/next/index.js

@@ -0,0 +1,195 @@
+import { t as compact } from "../compact-y6vfu2_f.js";
+import { t as createPermDock$1 } from "../permdock-yoZ7EjxX.js";
+import { t as emptySnapshot } from "../from-snapshot-BMGnhmgv.js";
+import { n as createEvaluationsHandler } from "../evaluations-DsAU9ppl.js";
+import { cache } from "react";
+import { jsx } from "react/jsx-runtime";
+import { io } from "next/cache";
+import { forbidden, unauthorized, unstable_rethrow } from "next/navigation";
+import { after } from "next/server";
+import { PermDockProvider } from "../react/provider-client.js";
+//#region src/next/cache-life.ts
+/**
+* `{ stale }` for `cacheLife()` inside an app-owned `'use cache: private'` function: `max` when the
+* value never expires, otherwise the seconds left, clamped to `[min, max]`. A value with less than
+* `min` seconds left gets its real remainder, so Next.js leaves it out of prefetches instead of
+* serving it past `expiresAt`.
+*/
+function cacheLifeFor(value, options = {}) {
+	const min = options.min ?? 30;
+	const max = Math.max(options.max ?? 300, min);
+	const expiresAt = value?.expiresAt;
+	if (expiresAt === void 0 || expiresAt === null) return { stale: max };
+	const issuedAt = value?.issuedAt !== void 0 && value.issuedAt > 0 ? value.issuedAt : void 0;
+	const now = options.now ?? issuedAt ?? Math.floor(Date.now() / 1e3);
+	const remaining = Math.floor(expiresAt - now);
+	if (remaining < min) return { stale: Math.max(0, remaining) };
+	return { stale: Math.min(max, remaining) };
+}
+//#endregion
+//#region src/next/provider.tsx
+function renderClientProvider(options) {
+	return /* @__PURE__ */ jsx(PermDockProvider, {
+		...compact({
+			snapshotPromise: options.snapshotPromise,
+			endpoint: options.endpoint,
+			tenant: options.tenant
+		}),
+		children: options.children
+	});
+}
+//#endregion
+//#region src/next/create.ts
+const DENIED = {
+	outcome: "denied",
+	denials: [{
+		role: null,
+		reason: "no-grant"
+	}],
+	alternatives: []
+};
+function assertServerOnly() {
+	if (globalThis.document !== void 0) throw new TypeError("permdock/next is server-only. Import hooks and Protected from permdock/react.");
+}
+async function readTenant(tenant) {
+	if (tenant === void 0 || typeof tenant === "string") return tenant;
+	try {
+		return await tenant();
+	} catch (error) {
+		unstable_rethrow(error);
+		return;
+	}
+}
+/** False outside a request or prerender scope, where `after()` throws. */
+function defer(task) {
+	try {
+		after(task);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function ignore() {}
+/**
+* Keeps the function alive until the sink has written and flushed: every
+* pending write and one `flush()` per render run in `after()`, so serverless
+* runtimes do not freeze with events still buffered.
+*/
+function afterResponse(sink) {
+	const flush = sink.flush?.bind(sink);
+	const scheduleFlush = cache(() => flush === void 0 ? false : defer(flush));
+	return {
+		write(events) {
+			const written = sink.write(events);
+			if (written !== void 0) defer(Promise.resolve(written).then(ignore, ignore));
+			scheduleFlush();
+			return written;
+		},
+		...flush === void 0 ? {} : { flush }
+	};
+}
+function wrapInstance(permdock, onDenied) {
+	if (onDenied === void 0) return permdock;
+	const assert = ((permission, data, options) => permdock.assert(permission, data, compact({
+		...options,
+		onDenied: options?.onDenied ?? onDenied
+	})));
+	return {
+		...permdock,
+		assert
+	};
+}
+function createPermDock(policy, options) {
+	assertServerOnly();
+	const sink = options.sink === void 0 ? void 0 : afterResponse(options.sink);
+	const resolveSubject = cache(async () => {
+		try {
+			return await options.subject();
+		} catch (error) {
+			unstable_rethrow(error);
+			return null;
+		}
+	});
+	const resolveFallbackTenant = cache(() => readTenant(options.tenant));
+	const instantiate = cache(async (tenantKey) => {
+		const tenant = tenantKey === "" ? void 0 : tenantKey;
+		const user = await resolveSubject();
+		await io();
+		const built = await createPermDock$1(policy, user, compact({
+			tenant,
+			memberships: options.memberships,
+			relations: options.relations,
+			entitlements: options.entitlements,
+			customRoles: options.customRoles,
+			policies: options.policies,
+			sink,
+			limits: options.limits
+		}));
+		return wrapInstance(options.otel === void 0 ? built : options.otel(built), options.onDenied);
+	});
+	const getPermDock = async (query) => {
+		const tenant = query?.tenant ?? await resolveFallbackTenant();
+		return instantiate(tenant ?? "");
+	};
+	const getPermission = async (permission, data) => {
+		try {
+			const decision = (await getPermDock()).decide(permission, data);
+			return {
+				allowed: decision.outcome === "granted",
+				status: "ready",
+				decision
+			};
+		} catch {
+			return {
+				allowed: false,
+				status: "ready",
+				decision: DENIED
+			};
+		}
+	};
+	const requireAccess = async (input) => {
+		const permdock = await getPermDock(input.tenant === void 0 ? void 0 : { tenant: input.tenant });
+		const assert = permdock.assert;
+		return assert(input.permission, input.data, { onDenied: (decision) => {
+			if (decision.outcome !== "denied" || decision.denials.some((denial) => denial.reason === "validation")) return;
+			if (permdock.subject.principal === null) unauthorized();
+			forbidden();
+		} });
+	};
+	const PermDockProvider = (props) => {
+		const snapshotPromise = getPermDock(props.tenant === void 0 ? void 0 : { tenant: props.tenant }).then((permdock) => permdock.snapshot(compact({
+			include: props.include,
+			tenants: props.tenants
+		}))).catch(() => emptySnapshot());
+		return renderClientProvider(compact({
+			snapshotPromise,
+			endpoint: props.endpoint ?? options.endpoint ?? "/api/permdock",
+			tenant: props.tenant,
+			children: props.children
+		}));
+	};
+	const permdockHandler = () => createEvaluationsHandler(compact({
+		policy,
+		getPermDock,
+		store: options.store
+	}));
+	return {
+		getPermDock,
+		getPermission,
+		requireAccess,
+		PermDockProvider,
+		permdockHandler
+	};
+}
+//#endregion
+//#region src/next/snapshot-tag.ts
+/**
+* The `cacheTag` for one subject's cached snapshots: `permdock:<sub>`, or `permdock:anon`
+* without a subject. Tag the private cache with it and pass it to `updateTag` or
+* `revalidateTag` on every write that changes the subject's snapshot.
+*/
+function snapshotTag(sub) {
+	return `permdock:${sub === void 0 || sub === null || sub === "" ? "anon" : sub}`;
+}
+//#endregion
+export { cacheLifeFor, createPermDock, snapshotTag };

package/dist/next/plugin.d.ts

@@ -0,0 +1,14 @@
+import { a as PermDockPluginOptions } from "../types-D6Z6-rKJ.js";
+//#region src/cli/plugin.d.ts
+/** Any object: Next's `NextConfig` is an interface, so no index signature. */
+type NextConfigLike = object;
+/** What `next.config` may export: an object, or a function of the phase. */
+type NextConfigInput<T extends NextConfigLike> = T | ((phase: string, context: NextConfigContext) => T | Promise<T>);
+type NextConfigContext = {
+  readonly defaultConfig?: unknown;
+};
+/** Next's config function: Next calls it with the phase constant. */
+type NextConfigFunction<T extends NextConfigLike> = (phase: string, context: NextConfigContext) => Promise<T>;
+export declare function createPermDockPlugin(options?: PermDockPluginOptions): <T extends NextConfigLike>(nextConfig: NextConfigInput<T>) => NextConfigFunction<T>;
+//#endregion
+export type { NextConfigContext, NextConfigFunction, NextConfigInput, NextConfigLike, PermDockPluginOptions };

package/dist/next/plugin.js

@@ -0,0 +1,2 @@
+import { t as createPermDockPlugin } from "../plugin-4gr7IxFJ.js";
+export { createPermDockPlugin };

package/dist/node/index.d.ts

@@ -0,0 +1,43 @@
+import { $ as DecisionSink, C as Policy, E as PolicyVocabulary, Zt as PermDock, at as LimitStore, ct as MembershipSource, ft as RelationSource, mr as Principal, pt as RoleSource, sn as PolicySource, tt as EntitlementSource, xt as SnapshotSource } from "../policy-CInmNGkM.js";
+import { d as Permission } from "../permissions-B4apnahQ.js";
+import { f as ApprovalStore } from "../types-B8w5PFtS.js";
+import { o as OtelWrap } from "../types-B9dmiiab.js";
+import { r as PdpFactory } from "../types-BvBk1wgn.js";
+import { g as discoverViaSignatureAgent, h as WebBotAuthVerifier, n as OpenApiHooks, o as TenantOption, r as ProtectOptions, t as Guard, u as InvalidSignatureError, y as verifyWebBotAuth } from "../create-BKF3dgFk.js";
+import { a as toRequest, i as sendResponse, n as fromResponse, r as isServerResponse, t as NodeRequest } from "../http-DPuDaChb.js";
+import { IncomingMessage, ServerResponse } from "node:http";
+//#region src/node/create.d.ts
+type NodePermDockOptions<TUser = unknown> = {
+  readonly subject: (req: NodeRequest) => TUser | Promise<TUser>;
+  readonly tenant?: TenantOption<NodeRequest>;
+  readonly memberships?: MembershipSource | readonly MembershipSource[];
+  /** The object graph for relation grants that walk a parent chain; without it they deny. */
+  readonly relations?: RelationSource;
+  readonly entitlements?: EntitlementSource;
+  readonly customRoles?: RoleSource;
+  /** Hosted grants, read once per instance; see `PolicySource`. */
+  readonly policies?: PolicySource;
+  readonly store?: ApprovalStore;
+  readonly sink?: DecisionSink;
+  readonly limits?: LimitStore;
+  /** `createPermDock` from `permdock/pdp`; `protect` then decides delegated permissions remotely. */
+  readonly pdp?: PdpFactory;
+  /** Accepted for adapter parity; not read by this adapter. */
+  readonly snapshots?: SnapshotSource;
+  /** `(permdock) => withOtel(permdock, options)` from `permdock/otel`. */
+  readonly otel?: OtelWrap;
+  /** `(request) => verifyWebBotAuth(request, options)`; a verified bot becomes the actor. */
+  readonly webBotAuth?: WebBotAuthVerifier;
+};
+type NodePermDock<V extends PolicyVocabulary = PolicyVocabulary> = {
+  readonly permdock: (req: IncomingMessage) => Promise<PermDock<V>>;
+  readonly protect: (permission: Permission, loadData?: (req: NodeRequest) => unknown, protectOptions?: ProtectOptions) => (req: IncomingMessage) => Promise<Guard>;
+  readonly send: typeof sendResponse;
+  readonly permdockHandler: () => (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+  readonly toRequest: typeof toRequest;
+  readonly fromResponse: typeof fromResponse;
+  readonly openapi: OpenApiHooks;
+};
+export declare function createPermDock<TUser, TPrincipal extends Principal = Principal, V extends PolicyVocabulary = PolicyVocabulary>(policy: Policy<TUser, TPrincipal, V>, options: NodePermDockOptions<TUser>): NodePermDock<V>;
+//#endregion
+export { InvalidSignatureError, type NodePermDock, type NodePermDockOptions, type NodeRequest, discoverViaSignatureAgent, fromResponse, isServerResponse, sendResponse, toRequest, verifyWebBotAuth };

package/dist/node/index.js

@@ -0,0 +1,66 @@
+import { t as compact } from "../compact-y6vfu2_f.js";
+import { i as discoverViaSignatureAgent, r as InvalidSignatureError, s as verifyWebBotAuth } from "../evaluations-DsAU9ppl.js";
+import { r as tenantScope, t as createKernel } from "../create-CSkhDU9T.js";
+import { i as toRequest, n as isServerResponse, r as sendResponse, t as fromResponse } from "../http-GgVApX1k.js";
+//#region src/node/create.ts
+function createPermDock(policy, options) {
+	const contexts = /* @__PURE__ */ new WeakMap();
+	const bound = /* @__PURE__ */ new WeakMap();
+	const kernel = createKernel(policy, compact({
+		subject: (request) => {
+			const req = contexts.get(request);
+			return req === void 0 ? null : options.subject(req);
+		},
+		memberships: options.memberships,
+		relations: options.relations,
+		entitlements: options.entitlements,
+		customRoles: options.customRoles,
+		policies: options.policies,
+		store: options.store,
+		sink: options.sink,
+		limits: options.limits,
+		pdp: options.pdp,
+		webBotAuth: options.webBotAuth,
+		adapter: "node",
+		wrap: options.otel
+	}));
+	const bind = (req) => {
+		const hit = bound.get(req);
+		if (hit !== void 0) return hit;
+		const nodeReq = req;
+		const request = toRequest(nodeReq);
+		bound.set(req, request);
+		contexts.set(request, nodeReq);
+		return request;
+	};
+	const scopeOf = (req) => tenantScope(options.tenant, req);
+	const permdock = async (req) => kernel.permdock(bind(req), await scopeOf(req));
+	const protect = (permission, loadData, protectOptions) => async (req) => kernel.protect(permission, loadData === void 0 ? void 0 : () => loadData(req), protectOptions)(bind(req), await scopeOf(req));
+	const permdockHandler = () => {
+		const { POST, GET } = kernel.permdockHandler((request) => {
+			const req = contexts.get(request);
+			return req === void 0 ? { tenant: void 0 } : scopeOf(req);
+		});
+		return async (req, res) => {
+			if (req.method === "GET" || req.method === "HEAD") {
+				await sendResponse(res, await GET(bind(req)));
+				return;
+			}
+			const nodeReq = req;
+			const request = toRequest(nodeReq);
+			contexts.set(request, nodeReq);
+			await sendResponse(res, await POST(request));
+		};
+	};
+	return {
+		permdock,
+		protect,
+		send: sendResponse,
+		permdockHandler,
+		toRequest,
+		fromResponse,
+		openapi: kernel.openapi
+	};
+}
+//#endregion
+export { InvalidSignatureError, createPermDock, discoverViaSignatureAgent, fromResponse, isServerResponse, sendResponse, toRequest, verifyWebBotAuth };

package/dist/openai/index.d.ts

@@ -0,0 +1,71 @@
+import { $ as DecisionSink, C as Policy, E as PolicyVocabulary, Zt as PermDock, at as LimitStore, ct as MembershipSource, ft as RelationSource, mr as Principal, pt as RoleSource, sn as PolicySource, tt as EntitlementSource, ur as Delegation, xt as SnapshotSource } from "../policy-CInmNGkM.js";
+import { d as Permission } from "../permissions-B4apnahQ.js";
+import { c as ApprovalRequest, f as ApprovalStore } from "../types-B8w5PFtS.js";
+import { t as ToolMap } from "../types-CxquUByI.js";
+//#region src/openai/create.d.ts
+/** The app context passed to `run(agent, input, { context })`. */
+type OpenAiContext = {
+  readonly user?: unknown;
+  readonly agentId?: string;
+  readonly permdockApproval?: string;
+  readonly [key: string]: unknown;
+};
+/** Structural `RunContext` from `@openai/agents`: the app context sits under `context`. */
+type OpenAiRunContext = {
+  readonly context?: unknown;
+};
+type OpenAiPermDockOptions<TUser = unknown> = {
+  readonly subject: (context: OpenAiContext) => TUser | Promise<TUser>;
+  readonly actor?: (context: OpenAiContext) => unknown;
+  readonly delegation?: (context: OpenAiContext) => Delegation | undefined | Promise<Delegation | undefined>;
+  readonly tenant?: string | ((context: OpenAiContext) => string | undefined | Promise<string | undefined>);
+  readonly tools: ToolMap;
+  readonly memberships?: MembershipSource | readonly MembershipSource[];
+  /** The object graph for relation grants that walk a parent chain; without it they deny. */
+  readonly relations?: RelationSource;
+  readonly entitlements?: EntitlementSource;
+  readonly customRoles?: RoleSource;
+  /** Hosted grants, read once per instance; see `PolicySource`. */
+  readonly policies?: PolicySource;
+  readonly store?: ApprovalStore;
+  readonly sink?: DecisionSink;
+  readonly limits?: LimitStore;
+  readonly snapshots?: SnapshotSource;
+};
+type OpenAiTool = {
+  readonly name: string;
+};
+/** Structural `RunToolApprovalItem` from `@openai/agents`. */
+type OpenAiInterruption = {
+  readonly type?: string;
+  readonly name?: string | undefined;
+  readonly arguments?: string | undefined;
+  readonly rawItem?: {
+    readonly type?: string;
+    readonly callId?: string;
+    readonly name?: string;
+    readonly arguments?: unknown;
+  };
+};
+/** Structural `RunState` from `@openai/agents`. */
+type OpenAiRunState<TItem> = {
+  approve(item: TItem, options?: {
+    alwaysApprove?: boolean;
+  }): unknown;
+  reject(item: TItem, options?: {
+    alwaysReject?: boolean;
+    message?: string;
+  }): unknown;
+};
+type OpenAiPermDock<V extends PolicyVocabulary = PolicyVocabulary> = {
+  /** A `ToolApprovalFunction`: pass it as a tool's `needsApproval`. */
+  readonly needsApproval: (permission: Permission) => (runContext: OpenAiRunContext | undefined, input: unknown, callId?: string) => Promise<boolean>;
+  readonly guardTools: <T extends OpenAiTool>(tools: readonly T[], context: OpenAiContext) => Promise<readonly T[]>;
+  readonly resolveInterruptions: <TItem extends OpenAiInterruption>(state: OpenAiRunState<TItem>, interruptions: readonly TItem[], options: {
+    readonly context: OpenAiContext;
+  }) => Promise<readonly ApprovalRequest[]>;
+  readonly permdock: (context: OpenAiContext) => Promise<PermDock<V>>;
+};
+export declare function createPermDock<TUser, TPrincipal extends Principal = Principal, V extends PolicyVocabulary = PolicyVocabulary>(policy: Policy<TUser, TPrincipal, V>, options: OpenAiPermDockOptions<TUser>): OpenAiPermDock<V>;
+//#endregion
+export type { OpenAiContext, OpenAiInterruption, OpenAiPermDock, OpenAiPermDockOptions, OpenAiRunState, OpenAiTool };

package/dist/openai/index.js

@@ -0,0 +1,105 @@
+import { t as compact } from "../compact-y6vfu2_f.js";
+import { p as memoryApprovalStore } from "../helpers-DnSOrhB9.js";
+import { n as createAgentKernel, t as approvalTokenOf } from "../kernel-YOGCWNLf.js";
+//#region src/openai/create.ts
+function appContext(runContext) {
+	const context = runContext?.context;
+	return typeof context === "object" && context !== null ? context : {};
+}
+function parseCall(item) {
+	const name = item.name ?? item.rawItem?.name;
+	if (typeof name !== "string") return { ok: false };
+	const raw = item.arguments ?? item.rawItem?.arguments;
+	if (typeof raw !== "string") return typeof raw === "object" && raw !== null ? {
+		ok: true,
+		name,
+		args: raw
+	} : { ok: false };
+	try {
+		return {
+			ok: true,
+			name,
+			args: JSON.parse(raw)
+		};
+	} catch {
+		return { ok: false };
+	}
+}
+function createPermDock(policy, options) {
+	const store = options.store ?? memoryApprovalStore();
+	const kernel = createAgentKernel(policy, {
+		...compact({
+			actor: options.actor,
+			delegation: options.delegation,
+			tenant: options.tenant,
+			memberships: options.memberships,
+			relations: options.relations,
+			entitlements: options.entitlements,
+			customRoles: options.customRoles,
+			policies: options.policies,
+			sink: options.sink,
+			limits: options.limits,
+			snapshots: options.snapshots
+		}),
+		subject: options.subject,
+		tools: options.tools,
+		store,
+		adapter: "openai"
+	});
+	const byPermission = /* @__PURE__ */ new Map();
+	for (const [name, binding] of Object.entries(options.tools)) byPermission.set(binding.permission.key, name);
+	const needsApproval = (permission) => async (runContext, input) => {
+		const toolName = byPermission.get(permission.key);
+		if (toolName === void 0) return true;
+		const context = appContext(runContext);
+		const binding = options.tools[toolName];
+		if (binding === void 0) return true;
+		try {
+			const can = (await kernel.instance(context)).can;
+			if (binding.data === void 0) return !can(permission);
+			const data = await binding.data(input);
+			if (data === null || data === void 0) return true;
+			return !can(permission, data);
+		} catch {
+			return true;
+		}
+	};
+	const guardTools = async (tools, context) => {
+		const allowed = await kernel.allowedToolNames(context);
+		return tools.filter((tool) => allowed.has(tool.name));
+	};
+	const resolveOne = async (state, item, context) => {
+		const call = parseCall(item);
+		if (!call.ok) {
+			await state.reject(item, { message: "Denied: unreadable tool call." });
+			return null;
+		}
+		const verdict = await kernel.decideTool(call.name, call.args, context, compact({ resumeToken: approvalTokenOf(context) }));
+		if (verdict.outcome === "granted") {
+			await state.approve(item);
+			return null;
+		}
+		if (verdict.outcome === "denied") {
+			await state.reject(item, { message: verdict.reason });
+			return null;
+		}
+		try {
+			return await store.get(verdict.token);
+		} catch {
+			return null;
+		}
+	};
+	const resolveInterruptions = async (state, interruptions, resolveOptions) => {
+		const resolved = [];
+		for (const item of interruptions) resolved.push(await resolveOne(state, item, resolveOptions.context));
+		return resolved.filter((record) => record !== null);
+	};
+	return {
+		needsApproval,
+		guardTools,
+		resolveInterruptions,
+		permdock: (context) => kernel.instance(context)
+	};
+}
+//#endregion
+export { createPermDock };

package/dist/openapi/index.d.ts

@@ -0,0 +1,93 @@
+import { C as Policy, _r as Condition, mr as Principal } from "../policy-CInmNGkM.js";
+import { d as Permission } from "../permissions-B4apnahQ.js";
+//#region src/openapi/types.d.ts
+type OpenApiTarget = "3.1" | "3.2" | "3.3";
+type OverlayVersion = "1.1" | "1.2";
+type SecurityProfileName = "fapi2";
+type SchemeType = "oauth2" | "openIdConnect" | "http" | "apiKey" | "gnap";
+type OpenApiSchemeOptions = {
+  readonly name: string;
+  readonly type: SchemeType;
+  readonly oauth2MetadataUrl?: string;
+  readonly flows?: {
+    readonly authorizationCode?: Readonly<Record<string, unknown>>;
+    readonly clientCredentials?: Readonly<Record<string, unknown>>;
+    readonly deviceAuthorization?: Readonly<Record<string, unknown>>;
+  };
+  readonly openIdConnectUrl?: string;
+  readonly ref?: string;
+  /** Retires the scheme: `deprecated` on 3.2 and 3.3, `x-oai-deprecated` on 3.1. */
+  readonly deprecated?: boolean;
+};
+type OpenApiDocsHints = {
+  readonly badges?: boolean;
+};
+type OpenApiPermDockOptions = {
+  readonly scheme: OpenApiSchemeOptions;
+  readonly target?: OpenApiTarget;
+  readonly securityProfile?: SecurityProfileName;
+  readonly profileScheme?: string;
+  readonly docsHints?: OpenApiDocsHints;
+};
+type OpenApiSecurityRequirement = Readonly<Record<string, readonly string[]>>;
+type OpenApiDescribe = {
+  readonly security: readonly OpenApiSecurityRequirement[];
+  readonly "x-permdock-permissions": readonly string[];
+  /** Keyed by permission key: the portable conditions of its allow grants. */
+  readonly "x-permdock-conditions"?: Readonly<Record<string, Condition>>;
+  /** Keyed by permission key: the permissions whose grants need an approval. */
+  readonly "x-permdock-approval"?: Readonly<Record<string, {
+    readonly reason: "human";
+  }>>;
+  readonly "x-permdock-securityProfile"?: SecurityProfileName;
+  readonly "x-badges"?: readonly {
+    readonly name: string;
+  }[];
+};
+/** One operation the Overlay targets, joined by `operationId`. */
+type OverlayOperation = {
+  readonly operationId: string;
+  readonly permissions: readonly Permission[];
+};
+type OpenApiOverlayOptions = {
+  readonly extends?: string;
+  readonly version?: OverlayVersion;
+  /** The operations to cover; without them, one per permission whose `operationId` is the permission key. */
+  readonly operations?: readonly OverlayOperation[];
+};
+type OpenApiPermDock = {
+  readonly securitySchemes: () => Readonly<Record<string, unknown>>;
+  readonly security: (permission: Permission | readonly Permission[], options?: {
+    readonly anyOf?: boolean;
+  }) => readonly OpenApiSecurityRequirement[];
+  readonly describe: (permission: Permission | readonly Permission[], options?: {
+    readonly anyOf?: boolean;
+  }) => OpenApiDescribe;
+  readonly spec: (permission: Permission | readonly Permission[]) => (operation: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+  readonly overlay: (options?: OpenApiOverlayOptions) => Record<string, unknown>;
+  /** One requirement per distinct scope set; without `scopeSets`, one per permission. */
+  readonly securityProfileRequirements: (scopeSets?: readonly (readonly string[])[]) => Readonly<Record<string, unknown>> | undefined;
+  readonly catalog: () => Record<string, unknown>;
+};
+type OpenApiFactory = <TUser, TPrincipal extends Principal = Principal>(policy: Policy<TUser, TPrincipal>, options: OpenApiPermDockOptions) => OpenApiPermDock;
+//#endregion
+//#region src/openapi/create.d.ts
+export declare const createPermDock: OpenApiFactory;
+//#endregion
+//#region src/openapi/pins.d.ts
+export declare const DRAFT_PINS: {
+  readonly oas: "3.3-dev@2026-09-01";
+  readonly securityProfiles: "oai-discussion-5304@2026-09-01";
+  readonly overlay: "1.2-dev@edd4adea";
+};
+export declare const PROFILE_NAMES: {
+  readonly fapi2: "fapi-20-security-profile";
+};
+export declare const GNAP_RESERVED = "scheme.type 'gnap' is reserved and emits nothing. See https://permdock.dev/docs/standards/watch-list#gnap";
+//#endregion
+//#region src/openapi/emit.d.ts
+export declare function securitySchemesOf(policy: Policy, options: OpenApiPermDockOptions): Record<string, unknown>;
+export declare function catalogOf(options: OpenApiPermDockOptions, extraDrafts?: Readonly<Record<string, string>>): Record<string, unknown>;
+export declare function openapiVersion(target: OpenApiTarget): string;
+//#endregion
+export type { OpenApiDescribe, OpenApiDocsHints, OpenApiFactory, OpenApiOverlayOptions, OpenApiPermDock, OpenApiPermDockOptions, OpenApiSchemeOptions, OpenApiSecurityRequirement, OpenApiTarget, OverlayOperation, OverlayVersion, SchemeType, SecurityProfileName };

package/dist/openapi/index.js

@@ -0,0 +1,3 @@
+import { n as GNAP_RESERVED, r as PROFILE_NAMES, t as DRAFT_PINS } from "../pins-CqE1jZuF.js";
+import { i as securitySchemesOf, n as catalogOf, r as openapiVersion, t as createPermDock } from "../openapi-DcqM8nU7.js";
+export { DRAFT_PINS, GNAP_RESERVED, PROFILE_NAMES, catalogOf, createPermDock, openapiVersion, securitySchemesOf };