permdock 0.0.0 → 0.1.0

package/dist/orpc/index.d.ts

@@ -0,0 +1,64 @@
+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 { n as RevocationFeed } from "../revocations-Cy06JNx2.js";
+import { r as PdpFactory } from "../types-BvBk1wgn.js";
+import { S as ConnectionOptions, b as Connection, h as WebBotAuthVerifier, n as OpenApiHooks, o as TenantOption } from "../create-BKF3dgFk.js";
+import { t as StreamProtectOptions } from "../stream-BhMfZOwr.js";
+import { Middleware } from "@orpc/server";
+//#region src/orpc/create.d.ts
+type OrpcMiddlewareOpts<TCtx extends object = object, TInput = unknown> = {
+  readonly context: TCtx;
+  readonly input?: TInput;
+  readonly path?: readonly string[];
+  readonly next: (opts?: {
+    readonly context: TCtx;
+  }) => Promise<unknown>;
+};
+type OrpcMiddleware<TCtx extends object = object, TInput = unknown, V extends PolicyVocabulary = PolicyVocabulary> = Middleware<TCtx, TCtx & {
+  readonly permdock: PermDock<V>;
+  readonly permdockData?: unknown;
+}, TInput, unknown, Record<never, never>>;
+type OrpcPermDockOptions<TCtx extends object = object, TUser = unknown> = {
+  readonly subject: (opts: OrpcMiddlewareOpts<TCtx>) => TUser | Promise<TUser>;
+  readonly tenant?: TenantOption<OrpcMiddlewareOpts<TCtx>>;
+  /** The Web `Request` behind a context; defaults to `context.request` or `context.req`. */
+  readonly request?: (context: TCtx) => Request | null | undefined;
+  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;
+  /** `(request) => verifyWebBotAuth(request, options)`; a verified bot becomes the actor. */
+  readonly webBotAuth?: WebBotAuthVerifier;
+  /** Ends or revalidates open event iterators. */
+  readonly revocations?: RevocationFeed;
+};
+type OrpcOpenApiHooks<TCtx extends object = object, V extends PolicyVocabulary = PolicyVocabulary> = {
+  readonly protect: (permission: Permission, loadData?: (opts: OrpcMiddlewareOpts<TCtx>) => unknown, protectOptions?: StreamProtectOptions) => OrpcMiddleware<TCtx, unknown, V>;
+  readonly security: (permission: Permission) => {
+    readonly security: readonly Record<string, readonly string[]>[];
+    readonly "x-permdock-permissions": readonly string[];
+  };
+  readonly securitySchemes: OpenApiHooks["securitySchemes"];
+};
+type OrpcPermDock<TCtx extends object = object, V extends PolicyVocabulary = PolicyVocabulary> = {
+  readonly permdock: () => OrpcMiddleware<TCtx, unknown, V>;
+  readonly protect: (permission: Permission, loadData?: (opts: OrpcMiddlewareOpts<TCtx>) => unknown, protectOptions?: StreamProtectOptions) => OrpcMiddleware<TCtx, unknown, V>;
+  /** A long-lived connection for the request behind `context`. */
+  readonly connection: (opts: OrpcMiddlewareOpts<TCtx>, connectionOptions?: ConnectionOptions) => Promise<Connection>;
+  readonly permdockHandler: (request: Request) => Promise<Response>;
+  readonly openapi: OrpcOpenApiHooks<TCtx, V>;
+};
+export declare function createPermDock<TCtx extends object = object, TUser = unknown, TPrincipal extends Principal = Principal, V extends PolicyVocabulary = PolicyVocabulary>(policy: Policy<TUser, TPrincipal, V>, options: OrpcPermDockOptions<TCtx, TUser>): OrpcPermDock<TCtx, V>;
+//#endregion
+export type { OrpcMiddleware, OrpcMiddlewareOpts, OrpcOpenApiHooks, OrpcPermDock, OrpcPermDockOptions };

package/dist/orpc/index.js

@@ -0,0 +1,188 @@
+import { t as compact } from "../compact-y6vfu2_f.js";
+import { o as invalidSignatureResponse } from "../evaluations-DsAU9ppl.js";
+import { r as tenantScope, t as createKernel } from "../create-CSkhDU9T.js";
+import { t as problemFromError } from "../map-error-RJ3ZsUyA.js";
+import { n as guardIterable, r as isAsyncIterable } from "../stream-Q_xlB6Ko.js";
+import { ORPCError } from "@orpc/server";
+//#region src/orpc/create.ts
+function hasBoundPermDock(context) {
+	return context !== null && typeof context === "object" && "permdock" in context && context.permdock !== void 0;
+}
+function requestFromCtx(ctx) {
+	if ("request" in ctx && ctx.request instanceof Request) return ctx.request;
+	if ("req" in ctx && ctx.req instanceof Request) return ctx.req;
+}
+function toOpts(mw, input, next) {
+	return compact({
+		context: mw.context,
+		input,
+		path: mw.path,
+		next
+	});
+}
+function problemMessage(cause, fallback) {
+	if (cause !== null && typeof cause === "object" && "detail" in cause && typeof cause.detail === "string" && cause.detail.length > 0) return cause.detail;
+	return fallback;
+}
+function orpcCode(status) {
+	switch (status) {
+		case 400: return "BAD_REQUEST";
+		case 401: return "UNAUTHORIZED";
+		case 404: return "NOT_FOUND";
+		case 429: return "TOO_MANY_REQUESTS";
+		case 503: return "SERVICE_UNAVAILABLE";
+		default: return "FORBIDDEN";
+	}
+}
+function orpcErrorFrom(error) {
+	const problem = error.toProblemDetails();
+	return new ORPCError(orpcCode(problem.status), {
+		message: error.code,
+		data: problem
+	});
+}
+async function throwOrpcError(response) {
+	let data;
+	try {
+		data = await response.json();
+	} catch {
+		data = { status: response.status };
+	}
+	const code = orpcCode(response.status);
+	throw new ORPCError(code, {
+		message: problemMessage(data, code),
+		data
+	});
+}
+/** A PermDock error thrown further down (an `assert` in a handler) becomes the ORPCError `protect` throws. */
+function mapDownstream(run) {
+	return new Promise((resolve) => {
+		resolve(run());
+	}).catch((error) => {
+		const mapped = problemFromError(error);
+		if (mapped === void 0) throw error;
+		return throwOrpcError(mapped);
+	});
+}
+function createPermDock(policy, options) {
+	const optsByRequest = /* @__PURE__ */ new WeakMap();
+	const requestByCtx = /* @__PURE__ */ new WeakMap();
+	const kernel = createKernel(policy, compact({
+		subject: (request) => {
+			const opts = optsByRequest.get(request);
+			return opts === void 0 ? null : options.subject(opts);
+		},
+		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,
+		revocations: options.revocations,
+		adapter: "orpc"
+	}));
+	const requestOf = (ctx) => {
+		if (options.request !== void 0) try {
+			return options.request(ctx) ?? void 0;
+		} catch {
+			return;
+		}
+		return requestFromCtx(ctx);
+	};
+	/**
+	* One `Request` per HTTP request, shared by every procedure in a batch. The
+	* subject reads the first procedure's opts; the tenant is resolved from each
+	* procedure's own opts in `scopeOf`, never through the shared `Request`.
+	*/
+	const bind = (opts) => {
+		const ctx = opts.context;
+		const hit = requestByCtx.get(ctx);
+		if (hit !== void 0) return hit;
+		const path = opts.path?.join(".") ?? "orpc";
+		const request = requestOf(opts.context) ?? new Request(`http://localhost/orpc/${path}`, { method: "POST" });
+		requestByCtx.set(ctx, request);
+		if (!optsByRequest.has(request)) optsByRequest.set(request, opts);
+		return request;
+	};
+	const scopeOf = (opts) => tenantScope(options.tenant, opts);
+	const attach = (ctx, request) => {
+		requestByCtx.set(ctx, request);
+	};
+	const permdock = () => ((mwOptions, input) => {
+		const opts = toOpts(mwOptions, input, mwOptions.next);
+		if (hasBoundPermDock(opts.context)) return mwOptions.next({ context: opts.context });
+		const request = bind(opts);
+		return scopeOf(opts).then((scope) => kernel.permdock(request, scope)).then((instance) => {
+			const nextCtx = {
+				...opts.context,
+				permdock: instance
+			};
+			attach(nextCtx, request);
+			return mapDownstream(() => mwOptions.next({ context: nextCtx }));
+		}, (error) => {
+			const response = invalidSignatureResponse(error);
+			if (response !== void 0) return throwOrpcError(response);
+			throw error;
+		});
+	});
+	const connection = async (opts, connectionOptions) => kernel.connection(bind(opts), connectionOptions, await scopeOf(opts));
+	/** Wraps an event iterator so revocation ends it and unreadable items drop. */
+	const guardOutput = async (result, opts, permission, loadData, protectOptions) => {
+		const output = result !== null && typeof result === "object" && "output" in result ? result.output : void 0;
+		if (!isAsyncIterable(output)) return result;
+		const conn = await connection(opts, compact({
+			permission,
+			data: loadData
+		}));
+		return {
+			...result,
+			output: guardIterable(output, conn, compact({
+				items: protectOptions?.items,
+				onRevoked: orpcErrorFrom
+			}))
+		};
+	};
+	const protect = (permission, loadData, protectOptions) => (async (mwOptions, input) => {
+		const opts = toOpts(mwOptions, input, mwOptions.next);
+		const request = bind(opts);
+		const guard = await kernel.protect(permission, loadData === void 0 ? void 0 : () => loadData(opts), protectOptions)(request, await scopeOf(opts));
+		if (guard.ok) {
+			const nextCtx = {
+				...opts.context,
+				permdock: guard.permdock,
+				permdockData: guard.data
+			};
+			attach(nextCtx, request);
+			return guardOutput(await mapDownstream(() => mwOptions.next({ context: nextCtx })), opts, permission, loadData === void 0 ? void 0 : () => loadData(opts), protectOptions);
+		}
+		return throwOrpcError(guard.response);
+	});
+	const permdockHandler = (request) => {
+		const opts = {
+			context: { req: request },
+			path: ["permdock"],
+			next: (nextOpts) => Promise.resolve(nextOpts ?? { context: { req: request } })
+		};
+		bind(opts);
+		const { POST, GET } = kernel.permdockHandler(() => scopeOf(opts));
+		return Promise.resolve(request.method === "GET" ? GET(request) : POST(request));
+	};
+	const kernelOpenApi = kernel.openapi;
+	return {
+		permdock,
+		protect,
+		connection,
+		permdockHandler,
+		openapi: {
+			protect,
+			security: kernelOpenApi.security,
+			securitySchemes: kernelOpenApi.securitySchemes
+		}
+	};
+}
+//#endregion
+export { createPermDock };

package/dist/otel/index.d.ts

@@ -0,0 +1,13 @@
+import { E as PolicyVocabulary, Zt as PermDock } from "../policy-CInmNGkM.js";
+import { a as OtelOptions, i as OtelApi, n as GEN_AI_TOOL_CALL_ID, o as OtelWrap, r as GEN_AI_TOOL_NAME, s as StructuralLogger, t as GENAI_SEMCONV_PIN } from "../types-B9dmiiab.js";
+//#region src/otel/instrument.d.ts
+/**
+ * Listens on one instance. Spans carry no duration and no histogram is
+ * recorded, because a listener only sees a decision after it is made; use
+ * `withOtel` for timings and for `tenant()` / `team()` derived instances.
+ */
+export declare function instrument(permdock: PermDock, options?: OtelOptions): () => void;
+/** Returns an instrumented instance: timed spans and histogram, derived instances included. */
+export declare function withOtel<V extends PolicyVocabulary = PolicyVocabulary>(permdock: PermDock<V>, options?: OtelOptions): PermDock<V>;
+//#endregion
+export { GENAI_SEMCONV_PIN, GEN_AI_TOOL_CALL_ID, GEN_AI_TOOL_NAME, type OtelApi, type OtelOptions, type OtelWrap, type StructuralLogger };

package/dist/otel/index.js

@@ -0,0 +1,202 @@
+import { t as compact } from "../compact-y6vfu2_f.js";
+//#region src/otel/types.ts
+const GENAI_SEMCONV_PIN = "1.37.0";
+const GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+const GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
+//#endregion
+//#region src/otel/instrument.ts
+const FORBIDDEN = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const SPAN_STATUS_ERROR = 2;
+const OTEL_REGISTRY = Symbol.for("opentelemetry.js.api.1");
+const OTEL_SPAN_KEY = Symbol.for("OpenTelemetry Context Key SPAN");
+function registry() {
+	const value = globalThis[OTEL_REGISTRY];
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+const NOOP_TRACER = { startSpan: () => ({}) };
+const registryApi = {
+	trace: {
+		getTracer: (name) => registry()?.trace?.getTracer?.(name) ?? NOOP_TRACER,
+		getActiveSpan: () => registry()?.context?.active?.()?.getValue?.(OTEL_SPAN_KEY)
+	},
+	metrics: { getMeter: (name) => registry()?.metrics?.getMeter?.(name) ?? {
+		createCounter: () => ({ add: () => void 0 }),
+		createHistogram: () => ({ record: () => void 0 })
+	} }
+};
+function resolveApi(injected) {
+	if (injected !== void 0) return injected;
+	return registry() === void 0 ? void 0 : registryApi;
+}
+function safeCall(fn, logger) {
+	try {
+		fn();
+	} catch (error) {
+		if (logger?.error !== void 0) try {
+			logger.error("permdock.otel", { cause: String(error) });
+		} catch {}
+	}
+}
+function omitPath(attributes, path) {
+	if (Object.hasOwn(attributes, path)) {
+		const next = {};
+		for (const key of Object.keys(attributes)) if (key !== path) next[key] = attributes[key];
+		return {
+			attributes: next,
+			matched: true
+		};
+	}
+	const parts = path.split(".");
+	if (parts.some((part) => FORBIDDEN.has(part))) return {
+		attributes,
+		matched: false
+	};
+	const [head, ...rest] = parts;
+	if (head === void 0 || rest.length === 0 || !Object.hasOwn(attributes, head)) return {
+		attributes,
+		matched: false
+	};
+	const nested = attributes[head];
+	if (nested === null || typeof nested !== "object") return {
+		attributes,
+		matched: false
+	};
+	const child = omitPath(nested, rest.join("."));
+	if (!child.matched) return {
+		attributes,
+		matched: false
+	};
+	return {
+		attributes: {
+			...attributes,
+			[head]: child.attributes
+		},
+		matched: true
+	};
+}
+function attributesOf(event, options, parent) {
+	const extra = options.attributes === void 0 ? {} : options.attributes(event);
+	let redacted = compact({
+		"permdock.outcome": event.outcome,
+		"permdock.permission": event.permission,
+		"permdock.scope": event.scope,
+		"permdock.resource.type": event.resource.type,
+		"permdock.resource.id": event.resource.id,
+		"permdock.subject.id": event.subject.principal?.id,
+		"permdock.actor.id": event.subject.actor?.id,
+		"permdock.actor.kind": event.subject.actor?.kind,
+		"permdock.delegation.scopes": event.subject.delegation?.scopes?.join(","),
+		"permdock.matched.role": event.matched?.role,
+		"permdock.denials.count": event.denials?.length,
+		"permdock.token": event.token,
+		"permdock.validate": event.trusted ? "trusted" : "boundary",
+		"permdock.adapter": event.adapter,
+		"permdock.filter.total": event.counts === void 0 ? void 0 : event.counts.granted + event.counts.denied + event.counts.approvalRequired,
+		"permdock.filter.kept": event.counts?.granted,
+		[GEN_AI_TOOL_NAME]: parent?.attributes?.[GEN_AI_TOOL_NAME],
+		[GEN_AI_TOOL_CALL_ID]: parent?.attributes?.[GEN_AI_TOOL_CALL_ID],
+		...extra
+	});
+	const unmatched = [];
+	for (const path of options.redact ?? []) {
+		const result = omitPath(redacted, path);
+		redacted = result.attributes;
+		if (!result.matched) unmatched.push(path);
+	}
+	if (unmatched.length > 0) safeCall(() => {
+		options.logger?.warn(`permdock.otel unmatched redact: ${unmatched.join(", ")}`);
+	}, options.logger);
+	return redacted;
+}
+/** Epoch milliseconds with sub-millisecond precision, the OTel `TimeInput` form. */
+function now() {
+	return performance.timeOrigin + performance.now();
+}
+function recordSignals(event, options, api, timing) {
+	const parent = api?.trace.getActiveSpan?.();
+	const attributes = attributesOf(event, options, parent);
+	if (options.logger !== void 0) safeCall(() => {
+		options.logger?.info("permdock.decision", attributes);
+	}, options.logger);
+	if (api === void 0) return;
+	const name = options.tracer ?? "permdock";
+	const span = api.trace.getTracer(name).startSpan("permdock.decide", timing === void 0 ? void 0 : { startTime: timing.start });
+	if (span.isRecording?.() === false) safeCall(() => {
+		options.logger?.warn("permdock.otel: @opentelemetry/api is present but no provider is registered");
+	}, options.logger);
+	span.setAttributes?.(attributes);
+	if (event.outcome === "denied") {
+		span.addEvent?.("permdock.denied", compact({
+			role: event.denials?.map((denial) => denial.role).join(","),
+			reason: event.denials?.map((denial) => denial.reason).join(","),
+			alternatives: event.alternatives?.join(",")
+		}));
+		if (event.denials?.some((denial) => denial.reason === "validation") === true) span.recordException?.(/* @__PURE__ */ new Error("validation"));
+		if (options.errorOnDeny === true) span.setStatus?.({ code: SPAN_STATUS_ERROR });
+	}
+	span.end?.(timing?.end);
+	const meter = api.metrics?.getMeter(name);
+	const counterAttrs = compact({
+		"permdock.outcome": event.outcome,
+		"permdock.permission": event.permission,
+		"permdock.adapter": event.adapter
+	});
+	meter?.createCounter("permdock.decisions").add(1, counterAttrs);
+	if (timing !== void 0) meter?.createHistogram("permdock.decide.duration", { unit: "s" }).record((timing.end - timing.start) / 1e3, counterAttrs);
+}
+function listen(permdock, options, api, startedAt) {
+	return permdock.on("decision", (payload) => {
+		const end = now();
+		const start = startedAt();
+		const event = payload;
+		safeCall(() => {
+			recordSignals(event, options, api, start === void 0 ? void 0 : {
+				start,
+				end
+			});
+		}, options.logger);
+	});
+}
+/**
+* Listens on one instance. Spans carry no duration and no histogram is
+* recorded, because a listener only sees a decision after it is made; use
+* `withOtel` for timings and for `tenant()` / `team()` derived instances.
+*/
+function instrument(permdock, options = {}) {
+	return listen(permdock, options, resolveApi(options.api), () => void 0);
+}
+function instrumented(permdock, options, api) {
+	let started;
+	listen(permdock, options, api, () => started);
+	const timed = (fn) => (...args) => {
+		const outer = started === void 0;
+		if (outer) started = now();
+		try {
+			return fn(...args);
+		} finally {
+			if (outer) started = void 0;
+		}
+	};
+	return Object.freeze({
+		...permdock,
+		can: timed(permdock.can),
+		decide: timed(permdock.decide),
+		assert: timed(permdock.assert),
+		explain: timed(permdock.explain),
+		filter: timed(permdock.filter),
+		pick: timed(permdock.pick),
+		actions: timed(permdock.actions),
+		tenant: (id) => instrumented(permdock.tenant(id), options, api),
+		team: (id) => instrumented(permdock.team(id), options, api)
+	});
+}
+/** Returns an instrumented instance: timed spans and histogram, derived instances included. */
+function withOtel(permdock, options = {}) {
+	return instrumented(permdock, options, resolveApi(options.api));
+}
+//#endregion
+export { GENAI_SEMCONV_PIN, GEN_AI_TOOL_CALL_ID, GEN_AI_TOOL_NAME, instrument, withOtel };

package/dist/package-root-zGkxO3oN.js

@@ -0,0 +1,30 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/cli/package-root.ts
+let cached;
+/**
+* The `permdock` package directory. The bundler may place this module in
+* `dist/cli/` or in a shared chunk at `dist/`, so walk up instead of
+* assuming a depth.
+*/
+function packageRoot() {
+	cached ??= findPackageRoot(dirname(fileURLToPath(import.meta.url)));
+	return cached;
+}
+/** The nearest directory at or above `start` whose `package.json` is named `permdock`. */
+function findPackageRoot(start) {
+	let dir = start;
+	for (;;) {
+		const manifest = join(dir, "package.json");
+		if (existsSync(manifest)) {
+			const { name } = JSON.parse(readFileSync(manifest, "utf8"));
+			if (name === "permdock") return dir;
+		}
+		const parent = dirname(dir);
+		if (parent === dir) throw new Error("PermDock CLI: cannot find the permdock package root");
+		dir = parent;
+	}
+}
+//#endregion
+export { packageRoot as t };

package/dist/parse-DPfIvFMU.js

@@ -0,0 +1,135 @@
+import { n as freezeDeep } from "./freeze-y1_jQL4v.js";
+import { i as PermDockValidationError } from "./errors-Iy71s7Oj.js";
+import { t as catalogSchema } from "./schema-P8yoma__.js";
+//#region src/catalog/parse.ts
+function issue(issues, path, message) {
+	issues.push({
+		message,
+		path: [...path]
+	});
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* A plain-data copy built from own enumerable keys, so `__proto__` stays an
+* ordinary key and nothing the input inherits is read. Anything JSON cannot
+* carry is an issue.
+*/
+function copyJson(value, path, issues, ancestors) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) issue(issues, path, "Expected a finite number");
+		return value;
+	}
+	if (typeof value !== "object") {
+		issue(issues, path, `Expected JSON, got ${typeof value}`);
+		return;
+	}
+	if (ancestors.has(value)) {
+		issue(issues, path, "Expected JSON, got a cycle");
+		return;
+	}
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) return value.map((item, index) => copyJson(item, [...path, index], issues, ancestors));
+		const proto = Object.getPrototypeOf(value);
+		if (proto !== Object.prototype && proto !== null) {
+			issue(issues, path, "Expected a plain object");
+			return;
+		}
+		return Object.fromEntries(Object.keys(value).map((key) => [key, copyJson(Reflect.get(value, key), [...path, key], issues, ancestors)]));
+	} finally {
+		ancestors.delete(value);
+	}
+}
+function typeMatches(type, value) {
+	switch (type) {
+		case "object": return isRecord(value);
+		case "array": return Array.isArray(value);
+		case "string": return typeof value === "string";
+		case "boolean": return typeof value === "boolean";
+		case "integer": return Number.isInteger(value);
+		default: return type;
+	}
+}
+/** The subset of JSON Schema 2020-12 `CatalogSchemaNode` names, over a `copyJson` result. */
+function checkSchema(node, value, path, issues) {
+	if ("const" in node && value !== node.const) {
+		issue(issues, path, `Expected ${JSON.stringify(node.const)}`);
+		return;
+	}
+	if (node.enum !== void 0 && !node.enum.includes(value)) {
+		issue(issues, path, `Expected one of ${node.enum.map((item) => JSON.stringify(item)).join(", ")}`);
+		return;
+	}
+	if (node.type !== void 0 && !typeMatches(node.type, value)) {
+		issue(issues, path, `Expected ${node.type}`);
+		return;
+	}
+	if (node.pattern !== void 0 && typeof value === "string" && !new RegExp(node.pattern, "u").test(value)) issue(issues, path, `Expected a string matching ${node.pattern}`);
+	if (node.minimum !== void 0 && typeof value === "number" && value < node.minimum) issue(issues, path, `Expected at least ${String(node.minimum)}`);
+	if (node.oneOf !== void 0) {
+		if (node.oneOf.filter((option) => {
+			const scratch = [];
+			checkSchema(option, value, path, scratch);
+			return scratch.length === 0;
+		}).length !== 1) issue(issues, path, "Expected exactly one matching form");
+	}
+	if (Array.isArray(value) && node.items !== void 0) for (const [index, item] of value.entries()) checkSchema(node.items, item, [...path, index], issues);
+	if (!isRecord(value)) return;
+	for (const key of node.required ?? []) if (!Object.hasOwn(value, key)) issue(issues, [...path, key], "Required");
+	const properties = node.properties ?? {};
+	for (const key of Object.keys(value)) {
+		const child = Object.hasOwn(properties, key) ? properties[key] : node.additionalProperties;
+		if (child !== void 0) checkSchema(child, value[key], [...path, key], issues);
+	}
+}
+function invalid(issues) {
+	const [first] = issues;
+	const where = first?.path === void 0 || first.path.length === 0 ? "" : ` at ${first.path.map(String).join(".")}`;
+	const more = issues.length > 1 ? ` (and ${String(issues.length - 1)} more)` : "";
+	throw new PermDockValidationError({
+		code: "invalid-data",
+		permission: "",
+		resource: "",
+		boundary: "catalog",
+		issues,
+		message: `PermDock: invalid catalog${where}: ${first?.message ?? "unknown"}${more}`
+	});
+}
+/**
+* Reads a `permissions.catalog.json` document (parsed, or the JSON text) and
+* validates it against `schemas/catalog-v1.json`. Returns a deep-frozen copy
+* built from own keys; throws `PermDockValidationError` with every issue.
+*/
+function parseCatalog(json) {
+	const issues = [];
+	let input = json;
+	if (typeof json === "string") try {
+		input = JSON.parse(json);
+	} catch (error) {
+		invalid([{
+			message: `Expected JSON text: ${error instanceof Error ? error.message : String(error)}`,
+			path: []
+		}]);
+	}
+	let copy;
+	try {
+		copy = copyJson(input, [], issues, /* @__PURE__ */ new Set());
+	} catch (error) {
+		invalid([{
+			message: `Could not read the input: ${error instanceof Error ? error.message : String(error)}`,
+			path: []
+		}]);
+	}
+	if (issues.length === 0) checkSchema(catalogSchema, copy, [], issues);
+	if (issues.length > 0) invalid(issues);
+	return freezeDeep(copy);
+}
+/** Keys of the permissions the catalog marks `rowConditions: true`: the SQL helpers alone cannot enforce them. */
+function rowConditionKeys(catalog) {
+	return new Set(catalog.permissions.filter((permission) => permission.rowConditions === true).map((permission) => permission.key));
+}
+//#endregion
+export { rowConditionKeys as n, parseCatalog as t };

package/dist/pdp/index.d.ts

@@ -0,0 +1,22 @@
+import { C as Policy, E as PolicyVocabulary, Q as DecisionProvider, Qt as PermDockOptions, mr as Principal } from "../policy-CInmNGkM.js";
+import { a as RelationMap, c as RemotePdpEndpoints, d as SpiceDbCheck, f as SpiceDbOptions, i as PdpPermDock, l as RemotePdpMapping, n as OpenFgaTuple, o as RemotePdpAuth, r as PdpFactory, s as RemotePdpCache, t as OpenFgaOptions, u as RemotePdpOptions } from "../types-BvBk1wgn.js";
+//#region src/pdp/create.d.ts
+export declare function createPermDock<TUser, TPrincipal extends Principal = Principal, V extends PolicyVocabulary = PolicyVocabulary>(policy: Policy<TUser, TPrincipal, V>, user: TUser | null, options?: PermDockOptions): Promise<PdpPermDock<V>>;
+//#endregion
+//#region src/pdp/relations.d.ts
+/**
+ * An OpenFGA store as a decision provider: `check` decides one row and
+ * `list-objects` lists the ids `filter` and `where` use.
+ */
+export declare function openfga(options: OpenFgaOptions): DecisionProvider;
+/**
+ * A SpiceDB HTTP gateway as a decision provider: `CheckPermission` decides
+ * one row and `LookupResources` lists the ids `filter` and `where` use. A
+ * conditional permissionship (a caveat missing context) is a denial.
+ */
+export declare function spicedb(options: SpiceDbOptions): DecisionProvider;
+//#endregion
+//#region src/pdp/remote.d.ts
+export declare function remotePdp(options: RemotePdpOptions): DecisionProvider;
+//#endregion
+export type { OpenFgaOptions, OpenFgaTuple, PdpFactory, PdpPermDock, RelationMap, RemotePdpAuth, RemotePdpCache, RemotePdpEndpoints, RemotePdpMapping, RemotePdpOptions, SpiceDbCheck, SpiceDbOptions };