permdock 0.0.0 → 0.1.0

package/dist/catalog-H-vFGwWK.js

@@ -0,0 +1,55 @@
+import { a as formatCatalogMarkdown, i as formatCatalogJson, r as catalogSchemaDocument, t as buildCatalog } from "./catalog-doc-BSo_Q_-6.js";
+import { n as listSourceFiles, t as defaultSrcPath } from "./files-B_wAGYmt.js";
+import { a as loadModule, i as loadConfiguredPolicy, o as pickNamed, r as leavesOf, t as asPermissionTree } from "./load-BZ24CpZP.js";
+import { n as scanSources, t as runCollect } from "./collect-O-tOtbnk.js";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+//#region src/cli/catalog.ts
+async function runCatalog(input) {
+	if (input.format === "schema") return {
+		code: 0,
+		output: `${JSON.stringify(catalogSchemaDocument(), null, 2)}\n`
+	};
+	const from = input.from ?? input.config.permissions;
+	let document;
+	if (from !== void 0) {
+		const abs = resolve(input.cwd, from);
+		if (!existsSync(abs)) return {
+			code: 2,
+			output: `PermDock CLI: module not found: ${from}`
+		};
+		const tree = asPermissionTree(pickNamed(await loadModule(abs), ["permissions"]));
+		const srcPath = input.config.collect?.srcPath ?? defaultSrcPath();
+		const files = listSourceFiles(input.cwd, srcPath);
+		const scan = scanSources(input.cwd, files, new Set(leavesOf(tree).map((leaf) => leaf.key)));
+		document = buildCatalog(tree, scan, input.now.toISOString(), await loadConfiguredPolicy(input.cwd, input.config.policy));
+	} else {
+		const collected = await runCollect({
+			cwd: input.cwd,
+			config: input.config,
+			collect: input.config.collect ?? {},
+			check: false,
+			now: input.now,
+			io: input.io
+		});
+		if (collected.document === void 0) return {
+			code: collected.code,
+			output: collected.message
+		};
+		document = collected.document;
+	}
+	const filtered = input.include.length === 0 ? document : {
+		...document,
+		permissions: document.permissions.filter((permission) => input.include.some((prefix) => permission.key === prefix || permission.key.startsWith(`${prefix}.`) || permission.resource === prefix))
+	};
+	if (input.format === "markdown") return {
+		code: 0,
+		output: formatCatalogMarkdown(filtered)
+	};
+	return {
+		code: 0,
+		output: formatCatalogJson(filtered)
+	};
+}
+//#endregion
+export { runCatalog as t };

package/dist/catalog-doc-BSo_Q_-6.js

@@ -0,0 +1,298 @@
+import { a as formerKeys, c as getResource, g as listPermissions } from "./permissions-DC7GROPA.js";
+import { t as catalogFingerprint } from "./src-CTNT-PBW.js";
+import { b as findRole } from "./grantee-Bv04_Vzf.js";
+import { l as canonicalJson } from "./snapshot-DE8dE_hz.js";
+import { t as byCodePoint } from "./compare-pfyVnBjE.js";
+import { t as catalogSchema } from "./schema-P8yoma__.js";
+import { o as generatorBanner, t as CATALOG_SCHEMA } from "./version-CnSh33Fj.js";
+//#region src/cli/catalog-doc.ts
+const ROW_GRANTEES = /* @__PURE__ */ new Set([
+	"relation",
+	"plan",
+	"actor",
+	"assurance"
+]);
+/**
+* Whether a grant depends on more than the role and the scope: a row or body
+* condition, a closure, a field list, a purpose, a break-glass override, a
+* validity window, or a relation, plan, actor or assurance grantee. The SQL helpers
+* (`permdock_has`, `permitted_<scope>_ids`) check only role and scope, so a
+* policy that calls them for such a permission would widen access.
+*/
+function grantHasRowConditions(grant) {
+	const grantees = Array.isArray(grant.to) ? grant.to : [grant.to];
+	return grant.where !== void 0 || grant.check !== void 0 || grant.closure !== void 0 || !grant.portable || grant.fields !== void 0 || grant.purpose !== void 0 || grant.breakGlass !== void 0 || grant.validity !== void 0 || grantees.some((grantee) => ROW_GRANTEES.has(grantee.kind));
+}
+/** Per permission key, whether any code grant for it has row conditions. */
+function policyRowConditionKeys(policy) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const grant of [...policy.grants, ...policy.roles.flatMap((binding) => binding.grants)]) if (grant.hosted === void 0 && grantHasRowConditions(grant)) keys.add(grant.permission.key);
+	return keys;
+}
+/** With `policy`, permissions carry `hostable` and a known `rowConditions` (without, it is `true`), and roles carry `on`, `assignable` and their ownership rules. */
+function buildCatalog(tree, scan, generatedAt, policy) {
+	const hostable = new Set(policy?.hostable ?? []);
+	const rowConditions = policy === void 0 ? void 0 : policyRowConditionKeys(policy);
+	const resources = {};
+	const definedIn = scan.definitionFiles["permissions"];
+	for (const leaf of listPermissions(tree)) {
+		if (resources[leaf.resource] !== void 0) continue;
+		const node = getResource(tree, leaf.resource);
+		resources[leaf.resource] = compactResource(definedIn === void 0 ? {
+			id: node?.id ?? "id",
+			schema: node === void 0 ? null : jsonSchemaOf(node),
+			relations: node?.relations,
+			version: node?.version,
+			restricted: node?.restricted
+		} : {
+			id: node?.id ?? "id",
+			schema: node === void 0 ? null : jsonSchemaOf(node),
+			definedIn,
+			relations: node?.relations,
+			version: node?.version,
+			restricted: node?.restricted
+		});
+	}
+	const approvals = codeApprovals(policy);
+	const breakGlass = codeBreakGlass(policy);
+	const body = {
+		resources,
+		permissions: listPermissions(tree).map((leaf) => withDefined({
+			key: leaf.key,
+			scope: leaf.scope,
+			resource: leaf.resource,
+			action: leaf.action,
+			arity: leaf.kind,
+			meta: metaRecord(leaf.meta),
+			usages: scan.usages[leaf.key] ?? [],
+			renamedFrom: formerKeys(leaf).length === 0 ? void 0 : formerKeys(leaf),
+			hostable: hostable.has(leaf.key) ? true : void 0,
+			rowConditions: rowConditions?.has(leaf.key) ?? true,
+			approvals: approvals.get(leaf.key),
+			breakGlass: breakGlass.get(leaf.key)
+		})).toSorted((a, b) => byCodePoint(a.key, b.key)),
+		...catalogScopes(policy),
+		...catalogRoles(scan.roleNames, policy),
+		...scan.planNames.length === 0 ? {} : { plans: scan.planNames.map((key) => ({ key })) },
+		...policy === void 0 ? {} : { grants: catalogGrants(policy) },
+		...policy?.delegations === void 0 ? {} : { delegations: catalogDelegations(policy) }
+	};
+	const head = {
+		$schema: CATALOG_SCHEMA,
+		version: 1,
+		generatedAt,
+		generator: generatorBanner()
+	};
+	return {
+		...head,
+		fingerprint: catalogFingerprint({
+			...head,
+			...body
+		}),
+		...body
+	};
+}
+function catalogApproval(approval) {
+	if (approval === void 0) return;
+	return approval === "human" ? "human" : withDefined({
+		by: approval.by,
+		mode: approval.mode,
+		stages: approval.stages,
+		distinct: approval.distinct,
+		staleOn: approval.staleOn,
+		quorum: approval.quorum,
+		ttl: approval.ttl,
+		escalation: approval.escalation
+	});
+}
+/**
+* Every code grant in canonical order: by permission, allows before denies,
+* then by role (top-level grants last) and finally by canonical JSON, so two
+* catalogs of the same policy list the same grants in the same order
+* whatever the declaration order was.
+*/
+function catalogGrant(grant) {
+	const limit = grant.limit === void 0 ? void 0 : withDefined({
+		count: grant.limit.count,
+		per: grant.limit.per,
+		mode: grant.limit.mode
+	});
+	return {
+		permission: grant.permission.key,
+		effect: grant.effect,
+		role: grant.role,
+		to: grant.to,
+		scope: grant.scope,
+		...withDefined({
+			where: grant.portable ? grant.where : void 0,
+			check: grant.portable ? grant.check : void 0,
+			approval: catalogApproval(grant.approval),
+			fields: grant.fields,
+			validity: grant.validity,
+			name: grant.name,
+			purpose: grant.purpose,
+			limit,
+			portable: grant.portable ? void 0 : false
+		})
+	};
+}
+/** The sort key of a catalog grant: permission, allows first, role (top-level last), then the canonical JSON. */
+function catalogGrantKey(grant) {
+	return [
+		grant.permission,
+		grant.effect === "allow" ? "0" : "1",
+		grant.role ?? "￿",
+		canonicalJson(grant)
+	].join("\0");
+}
+function catalogGrants(policy) {
+	const keys = /* @__PURE__ */ new Map();
+	const entries = policy.grants.filter((grant) => grant.hosted === void 0).map(catalogGrant);
+	for (const entry of entries) keys.set(entry, catalogGrantKey(entry));
+	const keyOf = (grant) => keys.get(grant) ?? "";
+	return entries.toSorted((a, b) => {
+		const left = keyOf(a);
+		const right = keyOf(b);
+		return left < right ? -1 : left > right ? 1 : 0;
+	});
+}
+/** Every policy delegation, sorted by canonical JSON so declaration order does not matter. */
+function catalogDelegations(policy) {
+	return (policy.delegations ?? []).map((delegation) => withDefined({
+		from: delegation.from,
+		to: delegation.to,
+		permissions: delegation.permissions,
+		validity: delegation.validity
+	})).toSorted((a, b) => {
+		const left = canonicalJson(a);
+		const right = canonicalJson(b);
+		return left < right ? -1 : left > right ? 1 : 0;
+	});
+}
+/** Per permission key, the distinct approvals the code allows require, in policy order. */
+function codeApprovals(policy) {
+	const out = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	for (const grant of policy?.grants ?? []) {
+		if (grant.effect !== "allow" || grant.hosted !== void 0 || grant.approval === void 0) continue;
+		const approval = catalogApproval(grant.approval);
+		if (approval === void 0) continue;
+		const id = `${grant.permission.key}\u0000${JSON.stringify(approval)}`;
+		if (seen.has(id)) continue;
+		seen.add(id);
+		out.set(grant.permission.key, [...out.get(grant.permission.key) ?? [], approval]);
+	}
+	return out;
+}
+/** Per permission key, the break-glass override a `breakGlass` grant declares. */
+function codeBreakGlass(policy) {
+	const out = /* @__PURE__ */ new Map();
+	for (const grant of policy?.grants ?? []) {
+		if (grant.breakGlass === void 0) continue;
+		out.set(grant.permission.key, withDefined({
+			overrides: grant.breakGlass.overrides,
+			purpose: grant.breakGlass.purpose,
+			reason: grant.breakGlass.reason,
+			maxDuration: grant.breakGlass.maxDuration,
+			obligations: grant.breakGlass.obligations
+		}));
+	}
+	return out;
+}
+function catalogScopes(policy) {
+	const scopes = policy?.scopes ?? [];
+	return scopes.length === 0 ? {} : { scopes: scopes.map((scope) => withDefined({
+		name: scope.name,
+		key: scope.key ?? "",
+		within: scope.within
+	})) };
+}
+function catalogRoles(scanned, policy) {
+	if (policy === void 0) return scanned.length === 0 ? {} : { roles: scanned.map((key) => ({ key })) };
+	const names = [.../* @__PURE__ */ new Set([...scanned, ...policy.roles.map((role) => role.name)])].toSorted();
+	if (names.length === 0) return {};
+	return { roles: names.map((key) => {
+		const binding = policy.rolesByName.get(key);
+		if (binding === void 0) return { key };
+		const audience = binding.meta?.audience ?? findRole(policy.vocabulary.roles, key)?.meta.audience;
+		return withDefined({
+			key,
+			on: binding.on === void 0 ? void 0 : typeof binding.on === "string" ? binding.on : "resource",
+			assignable: binding.assignable,
+			min: binding.min === 0 ? void 0 : binding.min,
+			max: binding.max,
+			transferOnly: binding.transferOnly === true ? true : void 0,
+			assigns: binding.assigns,
+			for: binding.for,
+			exclusiveWith: binding.exclusiveWith,
+			audience,
+			activation: binding.activation === void 0 ? void 0 : withDefined({
+				maxDuration: binding.activation.maxDuration,
+				justification: binding.activation.justification,
+				approval: binding.activation.approval === void 0 ? void 0 : true,
+				assurance: binding.activation.assurance
+			}),
+			supportAccess: binding.support === void 0 ? void 0 : {
+				actorRequired: binding.support.actorRequired,
+				group: binding.support.group,
+				durations: binding.support.consent.durations
+			}
+		});
+	}) };
+}
+function withDefined(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function compactResource(resource) {
+	const relations = resource.relations !== void 0 && Object.keys(resource.relations).length > 0 ? resource.relations : void 0;
+	return {
+		id: resource.id,
+		schema: resource.schema,
+		...withDefined({
+			definedIn: resource.definedIn,
+			relations,
+			version: resource.version,
+			restricted: resource.restricted
+		})
+	};
+}
+function metaRecord(meta) {
+	return { ...meta };
+}
+function jsonSchemaOf(node) {
+	const output = node.schema?.["~standard"]?.jsonSchema?.output;
+	if (typeof output === "function") try {
+		return output({ target: "draft-2020-12" });
+	} catch {
+		return null;
+	}
+	return null;
+}
+function formatCatalogJson(doc) {
+	return `${JSON.stringify(doc, null, 2)}\n`;
+}
+function catalogForCompare(doc) {
+	const { generatedAt: _generatedAt, generator: _generator, ...rest } = doc;
+	return `${JSON.stringify(rest, null, 2)}\n`;
+}
+function formatCatalogMarkdown(doc) {
+	const lines = ["# Permissions", ""];
+	const byResource = /* @__PURE__ */ new Map();
+	for (const permission of doc.permissions) {
+		const current = byResource.get(permission.resource) ?? [];
+		byResource.set(permission.resource, [...current, permission]);
+	}
+	for (const resource of [...byResource.keys()].toSorted()) {
+		lines.push(`## ${resource}`, "");
+		lines.push("| Action | Arity | Scope | Usages |");
+		lines.push("| --- | --- | --- | --- |");
+		for (const permission of byResource.get(resource) ?? []) lines.push(`| \`${permission.action}\` | ${permission.arity} | \`${permission.scope}\` | ${String(permission.usages.length)} |`);
+		lines.push("");
+	}
+	return `${lines.join("\n")}\n`;
+}
+function catalogSchemaDocument() {
+	return catalogSchema;
+}
+//#endregion
+export { formatCatalogMarkdown as a, formatCatalogJson as i, catalogForCompare as n, jsonSchemaOf as o, catalogSchemaDocument as r, policyRowConditionKeys as s, buildCatalog as t };

package/dist/catalog-idsHc0vo.js

@@ -0,0 +1,2 @@
+import { t as runCatalog } from "./catalog-H-vFGwWK.js";
+export { runCatalog };

package/dist/catalog-path-CnI0XTFK.js

@@ -0,0 +1,12 @@
+import { resolve } from "node:path";
+//#region src/cli/catalog-path.ts
+/**
+* The absolute path `permdock collect` writes the catalog to: `collect.out`,
+* then `catalog.out`, then `permissions.catalog.json`, resolved against `cwd`.
+* `out` overrides the config, as `collect --out` does.
+*/
+function catalogPath(config, cwd, out) {
+	return resolve(cwd, out ?? config.collect?.out ?? config.catalog?.out ?? "permissions.catalog.json");
+}
+//#endregion
+export { catalogPath as t };

package/dist/claude-agent/index.d.ts

@@ -0,0 +1,81 @@
+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 { f as ApprovalStore } from "../types-B8w5PFtS.js";
+import { t as ToolMap } from "../types-CxquUByI.js";
+//#region src/claude-agent/create.d.ts
+/** Structural `McpServerProvenance` from `@anthropic-ai/claude-agent-sdk`. */
+type ClaudeMcpServer = {
+  readonly name: string;
+  readonly source: string;
+};
+/**
+ * What `subject`, `actor` and `tenant` receive: the `canUseTool` options or
+ * the hook input. The subject comes from the app that started the query,
+ * never from these fields.
+ */
+type ClaudeAgentContext = {
+  readonly toolName: string;
+  readonly mcpServer?: ClaudeMcpServer;
+  readonly sessionId?: string;
+  readonly agentId?: string;
+};
+type ClaudeAgentPermDockOptions<TUser = unknown> = {
+  readonly subject: (context: ClaudeAgentContext) => TUser | Promise<TUser>;
+  readonly actor?: (context: ClaudeAgentContext) => unknown;
+  readonly delegation?: (context: ClaudeAgentContext) => Delegation | undefined | Promise<Delegation | undefined>;
+  readonly tenant?: string | ((context: ClaudeAgentContext) => string | undefined | Promise<string | undefined>);
+  readonly tools: ToolMap;
+  /** MCP server sources whose `mcp__*` tools may be decided; default `['sdk']`. */
+  readonly mcpSources?: readonly string[];
+  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 PermissionResult = {
+  readonly behavior: "allow";
+  readonly updatedInput: Record<string, unknown>;
+} | {
+  readonly behavior: "deny";
+  readonly message: string;
+};
+/** Structural `canUseTool` options from `@anthropic-ai/claude-agent-sdk`. */
+type CanUseToolOptions = {
+  readonly signal?: AbortSignal;
+  readonly mcpServer?: ClaudeMcpServer;
+  readonly agentID?: string;
+  readonly toolUseID?: string;
+};
+/** Structural `HookInput`; only `PermissionRequest` events are answered. */
+type PermissionRequestHookInput = {
+  readonly hook_event_name: string;
+  readonly session_id?: string;
+  readonly agent_id?: string;
+  readonly tool_name?: string;
+  readonly tool_input?: unknown;
+  readonly mcp_server?: ClaudeMcpServer;
+};
+type PermissionRequestHookOutput = {
+  readonly hookSpecificOutput: {
+    readonly hookEventName: "PermissionRequest";
+    readonly decision: PermissionResult;
+  };
+} | Record<string, never>;
+type ClaudeAgentPermDock<V extends PolicyVocabulary = PolicyVocabulary> = {
+  /** A `CanUseTool`: pass it as the query's `canUseTool` option. */
+  readonly canUseTool: (toolName: string, input: Record<string, unknown>, options?: CanUseToolOptions) => Promise<PermissionResult>;
+  /** A `HookCallback` for the `PermissionRequest` event. */
+  readonly permissionRequestHook: (input: PermissionRequestHookInput, toolUseID?: string, options?: {
+    readonly signal?: AbortSignal;
+  }) => Promise<PermissionRequestHookOutput>;
+  readonly permdock: (context: ClaudeAgentContext) => Promise<PermDock<V>>;
+};
+export declare function createPermDock<TUser, TPrincipal extends Principal = Principal, V extends PolicyVocabulary = PolicyVocabulary>(policy: Policy<TUser, TPrincipal, V>, options: ClaudeAgentPermDockOptions<TUser>): ClaudeAgentPermDock<V>;
+//#endregion
+export type { CanUseToolOptions, ClaudeAgentContext, ClaudeAgentPermDock, ClaudeAgentPermDockOptions, ClaudeMcpServer, PermissionRequestHookInput, PermissionRequestHookOutput, PermissionResult };

package/dist/claude-agent/index.js

@@ -0,0 +1,83 @@
+import { t as compact } from "../compact-y6vfu2_f.js";
+import { n as createAgentKernel } from "../kernel-YOGCWNLf.js";
+//#region src/claude-agent/create.ts
+const MCP_PREFIX = "mcp__";
+function asInput(input) {
+	if (input !== null && typeof input === "object" && !Array.isArray(input)) return input;
+	return {};
+}
+function untrustedServer(context, sources) {
+	if (!context.toolName.startsWith(MCP_PREFIX)) return;
+	const server = context.mcpServer;
+	if (server === void 0) return `Denied: ${context.toolName} has no MCP server provenance.`;
+	if (!sources.includes(server.source)) return `Denied: ${context.toolName} comes from an untrusted MCP server source.`;
+	if (!context.toolName.startsWith(`${MCP_PREFIX}${server.name}__`)) return `Denied: ${context.toolName} is not served by the MCP server that claims it.`;
+}
+function toResult(verdict, input) {
+	if (verdict.outcome === "granted") return {
+		behavior: "allow",
+		updatedInput: asInput(input)
+	};
+	if (verdict.outcome === "denied") return {
+		behavior: "deny",
+		message: verdict.reason
+	};
+	return {
+		behavior: "deny",
+		message: `${verdict.summary} Approval ${verdict.token} is pending; retry the call once it is approved.`
+	};
+}
+function createPermDock(policy, options) {
+	const sources = options.mcpSources ?? ["sdk"];
+	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,
+			store: options.store,
+			sink: options.sink,
+			limits: options.limits,
+			snapshots: options.snapshots
+		}),
+		subject: options.subject,
+		tools: options.tools,
+		adapter: "claude-agent"
+	});
+	const decide = async (context, input) => {
+		const untrusted = untrustedServer(context, sources);
+		if (untrusted !== void 0) return {
+			behavior: "deny",
+			message: untrusted
+		};
+		return toResult(await kernel.decideTool(context.toolName, input, context), input);
+	};
+	const canUseTool = (toolName, input, sdkOptions = {}) => decide(compact({
+		toolName,
+		mcpServer: sdkOptions.mcpServer,
+		agentId: sdkOptions.agentID
+	}), input);
+	const permissionRequestHook = async (input) => {
+		if (input.hook_event_name !== "PermissionRequest" || typeof input.tool_name !== "string") return {};
+		return { hookSpecificOutput: {
+			hookEventName: "PermissionRequest",
+			decision: await decide(compact({
+				toolName: input.tool_name,
+				mcpServer: input.mcp_server,
+				sessionId: input.session_id,
+				agentId: input.agent_id
+			}), input.tool_input)
+		} };
+	};
+	return {
+		canUseTool,
+		permissionRequestHook,
+		permdock: (context) => kernel.instance(context)
+	};
+}
+//#endregion
+export { createPermDock };

package/dist/clerk/index.d.ts

@@ -0,0 +1,56 @@
+import { hr as Subject, mr as Principal, pt as RoleSource } from "../policy-CInmNGkM.js";
+import { d as Permission } from "../permissions-B4apnahQ.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/clerk/types.d.ts
+type ClerkPrincipal = Principal & {
+  readonly clerkPermissions?: readonly string[];
+  readonly claims?: Readonly<Record<string, unknown>>;
+  readonly featureSources?: Readonly<Record<string, "o" | "u">>;
+};
+type ClerkMembershipListItem = {
+  readonly organization?: {
+    readonly id?: string;
+  };
+  readonly organizationId?: string;
+  readonly role?: string;
+  readonly publicUserData?: {
+    readonly userId?: string;
+  } | null;
+};
+type ClerkBackend = {
+  readonly users?: {
+    readonly getOrganizationMembershipList?: (args: {
+      readonly userId: string;
+      readonly limit?: number;
+      readonly offset?: number;
+    }) => Promise<{
+      readonly data?: readonly ClerkMembershipListItem[];
+      readonly totalCount?: number;
+    } | readonly ClerkMembershipListItem[]>;
+  };
+};
+type ClerkGlobalRoles = string | ((claims: Readonly<Record<string, unknown>>) => readonly string[]);
+type ClerkSubjectOptions = {
+  readonly memberships?: "active" | "all";
+  readonly backend?: ClerkBackend;
+  readonly customRoles?: RoleSource;
+  readonly permissions?: Readonly<Record<string, Permission>>;
+  readonly schema?: StandardSchemaV1;
+  readonly globalRoles?: ClerkGlobalRoles;
+  readonly features?: Readonly<Record<string, string>>;
+  readonly declared?: readonly string[];
+};
+type ClerkAuthObject = {
+  readonly userId?: string | null;
+  readonly orgId?: string | null;
+  readonly orgRole?: string | null;
+  readonly orgPermissions?: readonly string[] | null;
+  readonly sessionId?: string | null;
+  readonly sessionClaims?: Readonly<Record<string, unknown>> | null;
+  readonly has?: (...args: never[]) => unknown;
+};
+//#endregion
+//#region src/clerk/subject.d.ts
+export declare function subjectFromClerk(authObject: unknown, options?: ClerkSubjectOptions): Promise<Subject<ClerkPrincipal>>;
+//#endregion
+export type { ClerkAuthObject, ClerkBackend, ClerkGlobalRoles, ClerkMembershipListItem, ClerkPrincipal, ClerkSubjectOptions };