@zudojs/permissions 0.0.1 → 1.0.0

package/dist/http/index.d.ts

@@ -1,11 +1,15 @@
 /**
  * HTTP middleware adapter for @zudojs/permissions.
  *
- * Requires @zudojs/http as a peer dependency.
+ * The HTTP types are mirrored locally in `httpTypes.ts` so this package has no
+ * hard dependency on @zudojs/http, which is an optional peer. The mirror is
+ * structural: anything satisfying the real `HttpMiddlewareContext` satisfies
+ * the local one, so the middleware composes with the real pipeline. Keep the
+ * two in step when @zudojs/http changes — nothing here can check it for you.
  *
  * @module http
  */
-export { createActorMiddleware, createRequirePermissionMiddleware, authorize, createRequirePermissionsMiddleware, ACTOR_STATE_KEY, DECISION_STATE_KEY, type AuthorizeMiddlewareOptions, type RequirePermissionMiddlewareOptions, } from "./httpMiddleware.core.js";
-export { createForbiddenResponse, createJsonResponse, type DeniedResponseOptions, } from "./httpHelpers.js";
+export { createActorMiddleware, createRequirePermissionMiddleware, authorize, createRequirePermissionsMiddleware, ACTOR_STATE_KEY, DECISION_STATE_KEY, DECISIONS_STATE_KEY, type AuthorizeMiddlewareOptions, type ActorMiddlewareOptions, type RequirePermissionMiddlewareOptions, type RequirePermissionsMiddlewareOptions, } from "./httpMiddleware.core.js";
+export { createForbiddenResponse, createUnauthorizedResponse, createJsonResponse, type DeniedResponseOptions, type PermissionHttpResponse, } from "./httpHelpers.js";
 export type { HttpMiddleware, HttpMiddlewareContext, HttpRequestContext, HttpResponseContext, HttpMiddlewareState, } from "./httpTypes.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/http/index.js

@@ -1,10 +1,14 @@
 /**
  * HTTP middleware adapter for @zudojs/permissions.
  *
- * Requires @zudojs/http as a peer dependency.
+ * The HTTP types are mirrored locally in `httpTypes.ts` so this package has no
+ * hard dependency on @zudojs/http, which is an optional peer. The mirror is
+ * structural: anything satisfying the real `HttpMiddlewareContext` satisfies
+ * the local one, so the middleware composes with the real pipeline. Keep the
+ * two in step when @zudojs/http changes — nothing here can check it for you.
  *
  * @module http
  */
-export { createActorMiddleware, createRequirePermissionMiddleware, authorize, createRequirePermissionsMiddleware, ACTOR_STATE_KEY, DECISION_STATE_KEY, } from "./httpMiddleware.core.js";
-export { createForbiddenResponse, createJsonResponse, } from "./httpHelpers.js";
+export { createActorMiddleware, createRequirePermissionMiddleware, authorize, createRequirePermissionsMiddleware, ACTOR_STATE_KEY, DECISION_STATE_KEY, DECISIONS_STATE_KEY, } from "./httpMiddleware.core.js";
+export { createForbiddenResponse, createUnauthorizedResponse, createJsonResponse, } from "./httpHelpers.js";
 //# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -4,7 +4,8 @@
  * Authorization engine for the Zudojs framework.
  *
  * Supports RBAC, ABAC, resource policies, wildcards, role hierarchy,
- * condition combinators, ability compilation, and explain mode.
+ * condition combinators, ability compilation, decision caching, audit events
+ * and explain mode.
  *
  * @module @zudojs/permissions
  */
@@ -23,5 +24,5 @@ export * from "./cache/index.js";
 export * from "./observability/index.js";
 export * from "./utils/index.js";
 export * from "./http/index.js";
-export { createPermissionEngine, type PermissionEngine, type PermissionEngineOptions, } from "./evaluator/authorizationEngine.js";
+export type { RoleSource, PolicySource, } from "./evaluator/authorizationEngine.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4,7 +4,8 @@
  * Authorization engine for the Zudojs framework.
  *
  * Supports RBAC, ABAC, resource policies, wildcards, role hierarchy,
- * condition combinators, ability compilation, and explain mode.
+ * condition combinators, ability compilation, decision caching, audit events
+ * and explain mode.
  *
  * @module @zudojs/permissions
  */
@@ -23,5 +24,4 @@ export * from "./cache/index.js";
 export * from "./observability/index.js";
 export * from "./utils/index.js";
 export * from "./http/index.js";
-export { createPermissionEngine, } from "./evaluator/authorizationEngine.js";
 //# sourceMappingURL=index.js.map

package/dist/observability/index.d.ts

@@ -3,5 +3,5 @@
  *
  * @module observability
  */
-export { createPermissionEventEmitter, withObservability, type PermissionCheckEvent, type PermissionEventHandler, } from "./observability.core.js";
+export { createPermissionEventEmitter, withObservability, type PermissionCheckEvent, type PermissionEventHandler, type PermissionEventEmitter, type PermissionEventEmitterOptions, } from "./observability.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/observability/observability.core.d.ts

@@ -12,30 +12,50 @@ export interface PermissionCheckEvent {
     readonly permission: string;
     /** Resource type (if available). */
     readonly resourceType?: string;
-    /** Whether allowed. */
+    /** Whether allowed. A check that threw is recorded as not allowed. */
     readonly allowed: boolean;
-    /** Decision reason. */
+    /** Decision reason, or `error:<Name>` when the check threw. */
     readonly reason?: string;
     /** Evaluation duration in ms. */
     readonly durationMs: number;
+    /** Whether the check ended in an exception rather than a decision. */
+    readonly errored?: boolean;
 }
 /** Handler for permission events. */
 export type PermissionEventHandler = (event: PermissionCheckEvent) => void;
-/**
- * Create a permission event emitter.
- */
-export declare function createPermissionEventEmitter(): {
-    /** Register an event handler. */
+/** Emits authorization audit events. */
+export interface PermissionEventEmitter {
+    /** Register a handler. Returns an unsubscribe function. */
     on(handler: PermissionEventHandler): () => void;
     /** Emit a permission check event. */
     emit(event: PermissionCheckEvent): void;
-};
+    /** Number of registered handlers. */
+    readonly size: number;
+}
+/** Options for {@link createPermissionEventEmitter}. */
+export interface PermissionEventEmitterOptions {
+    /**
+     * Reports a handler that threw.
+     *
+     * Handler errors are swallowed so a broken audit sink cannot break
+     * authorization — but a sink that is silently failing is worse than one
+     * that is loudly failing, so this is where it surfaces.
+     */
+    readonly onHandlerError?: (error: unknown, event: PermissionCheckEvent) => void;
+}
+/**
+ * Create a permission event emitter.
+ */
+export declare function createPermissionEventEmitter(options?: PermissionEventEmitterOptions): PermissionEventEmitter;
 /**
  * Wrap a permission check with observability.
  *
- * @param emitter - The event emitter.
- * @param fn - The permission check function.
- * @returns Wrapped function that emits events.
+ * The event is emitted from a `finally`, so a check that throws is recorded
+ * too — the exception paths are exactly the ones an audit trail must not
+ * miss.
+ *
+ * Prefer passing an emitter to `createPermissionEngine({ emitter })`, which
+ * instruments every check the engine makes.
  */
-export declare function withObservability<T extends (...args: readonly unknown[]) => Promise<PermissionDecision>>(emitter: ReturnType<typeof createPermissionEventEmitter>, fn: T): T;
+export declare function withObservability<TArgs extends readonly unknown[]>(emitter: PermissionEventEmitter, fn: (...args: TArgs) => Promise<PermissionDecision>): (...args: TArgs) => Promise<PermissionDecision>;
 //# sourceMappingURL=observability.core.d.ts.map

package/dist/observability/observability.core.js

@@ -6,49 +6,70 @@
 /**
  * Create a permission event emitter.
  */
-export function createPermissionEventEmitter() {
+export function createPermissionEventEmitter(options) {
     const handlers = new Set();
     return {
-        /** Register an event handler. */
         on(handler) {
             handlers.add(handler);
             return () => {
                 handlers.delete(handler);
             };
         },
-        /** Emit a permission check event. */
         emit(event) {
             for (const handler of handlers) {
                 try {
                     handler(event);
                 }
-                catch {
-                    // Swallow handler errors to prevent breaking authorization
+                catch (error) {
+                    options?.onHandlerError?.(error, event);
                 }
             }
         },
+        get size() {
+            return handlers.size;
+        },
     };
 }
 /**
  * Wrap a permission check with observability.
  *
- * @param emitter - The event emitter.
- * @param fn - The permission check function.
- * @returns Wrapped function that emits events.
+ * The event is emitted from a `finally`, so a check that throws is recorded
+ * too — the exception paths are exactly the ones an audit trail must not
+ * miss.
+ *
+ * Prefer passing an emitter to `createPermissionEngine({ emitter })`, which
+ * instruments every check the engine makes.
  */
 export function withObservability(emitter, fn) {
-    return (async (...args) => {
+    return async (...args) => {
         const start = performance.now();
-        const decision = await fn(...args);
-        const durationMs = performance.now() - start;
-        emitter.emit({
-            actorId: args[0]?.id ?? "unknown",
-            permission: args[1] ?? "unknown",
-            allowed: decision.allowed,
-            reason: decision.reason,
-            durationMs,
-        });
-        return decision;
-    });
+        let decision;
+        let failure;
+        try {
+            decision = await fn(...args);
+            return decision;
+        }
+        catch (error) {
+            failure = error;
+            throw error;
+        }
+        finally {
+            const actor = args[0];
+            const resource = args[2];
+            emitter.emit({
+                actorId: actor?.id ?? "unknown",
+                permission: typeof args[1] === "string" ? args[1] : "unknown",
+                resourceType: typeof resource === "object" && resource !== null
+                    ? (resource.type ??
+                        resource.constructor?.name)
+                    : undefined,
+                allowed: decision?.allowed ?? false,
+                reason: decision?.reason ??
+                    (failure instanceof Error ? `error:${failure.name}` : undefined),
+                durationMs: performance.now() - start,
+                errored: failure !== undefined,
+            });
+        }
+    };
 }
 //# sourceMappingURL=observability.core.js.map

package/dist/permission/index.d.ts

@@ -3,6 +3,6 @@
  *
  * @module permission
  */
-export { parsePermission, isValidPermission, matches, matchesPermission, } from "./permission.core.js";
-export { createPermissionRegistry, type PermissionRegistryOptions, } from "./permissionRegistry.js";
+export { parsePermission, parsePermissionSafe, isValidPermission, matches, matchesPermission, formatPermission, } from "./permission.core.js";
+export { createPermissionRegistry, type PermissionRegistry, type PermissionRegistryOptions, type RegisteredPermission, } from "./permissionRegistry.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/permission/index.js

@@ -3,6 +3,6 @@
  *
  * @module permission
  */
-export { parsePermission, isValidPermission, matches, matchesPermission, } from "./permission.core.js";
+export { parsePermission, parsePermissionSafe, isValidPermission, matches, matchesPermission, formatPermission, } from "./permission.core.js";
 export { createPermissionRegistry, } from "./permissionRegistry.js";
 //# sourceMappingURL=index.js.map

package/dist/permission/permission.core.d.ts

@@ -9,6 +9,7 @@ import type { Permission } from "../permissionTypes/index.js";
  *
  * @example parsePermission("post:update") → { resource: "post", action: "update" }
  * @example parsePermission("billing.invoice:refund") → { resource: "billing.invoice", action: "refund" }
+ * @throws InvalidPermissionError if the string is not a valid permission
  */
 export declare function parsePermission(permission: string): Permission;
 /**
@@ -16,15 +17,25 @@ export declare function parsePermission(permission: string): Permission;
  */
 export declare function isValidPermission(permission: string): boolean;
 /**
- * Check if a permission matches a target permission, supporting wildcards.
+ * Check if a permission pattern matches a target permission.
+ *
+ * Uses the same wildcard rules as the rule engine, so `billing.*:read`
+ * means the same thing whether it is written as a grant, a deny, or a rule.
  *
  * @example matches("post:*", "post:update") → true
  * @example matches("*:*", "anything:goes") → true
+ * @example matches("billing.*:read", "billing.invoice:read") → true
  * @example matches("post:read", "post:update") → false
  */
 export declare function matches(pattern: string, target: string): boolean;
 /**
- * Check if a permission string matches a structured Permission object.
+ * Check if a permission pattern matches a structured Permission object.
  */
 export declare function matchesPermission(pattern: string, permission: Permission): boolean;
+/**
+ * Parse a permission string, returning null on invalid format instead of throwing.
+ */
+export declare function parsePermissionSafe(permission: string): Permission | null;
+/** Build a permission string from a resource and an action. */
+export declare function formatPermission(resource: string, action: string): string;
 //# sourceMappingURL=permission.core.d.ts.map

package/dist/permission/permission.core.js

@@ -4,22 +4,29 @@
  * @module permission/permission
  */
 import { InvalidPermissionError } from "../permissionErrors/index.js";
-/** Regex for valid permission format: resource:action (supports namespaces and wildcards). */
-const PERMISSION_REGEX = /^[a-zA-Z0-9._*-]+:[a-zA-Z0-9._*-]+$/;
+import { patternStrMatches } from "../rule/rule.core.js";
+/**
+ * Valid permission format: `resource:action`.
+ *
+ * A segment is either a bare `*`, a namespace wildcard such as `billing.*`,
+ * or a literal name. A partial wildcard like `post*` is rejected: the matcher
+ * has no meaning for it, so accepting one produced a grant that silently
+ * never matched anything.
+ */
+const SEGMENT = String.raw `(?:\*|[a-zA-Z0-9._-]+(?:\.\*)?)`;
+const PERMISSION_REGEX = new RegExp(`^${SEGMENT}:${SEGMENT}$`);
 /**
  * Parse a permission string into a structured Permission.
  *
  * @example parsePermission("post:update") → { resource: "post", action: "update" }
  * @example parsePermission("billing.invoice:refund") → { resource: "billing.invoice", action: "refund" }
+ * @throws InvalidPermissionError if the string is not a valid permission
  */
 export function parsePermission(permission) {
-    if (!PERMISSION_REGEX.test(permission)) {
+    const parsed = parsePermissionSafe(permission);
+    if (!parsed)
         throw new InvalidPermissionError(permission);
-    }
-    const lastColon = permission.lastIndexOf(":");
-    const resource = permission.slice(0, lastColon);
-    const action = permission.slice(lastColon + 1);
-    return Object.freeze({ resource, action });
+    return Object.freeze(parsed);
 }
 /**
  * Check if a permission string is valid without throwing.
@@ -28,40 +35,37 @@ export function isValidPermission(permission) {
     return PERMISSION_REGEX.test(permission);
 }
 /**
- * Check if a permission matches a target permission, supporting wildcards.
+ * Check if a permission pattern matches a target permission.
+ *
+ * Uses the same wildcard rules as the rule engine, so `billing.*:read`
+ * means the same thing whether it is written as a grant, a deny, or a rule.
  *
  * @example matches("post:*", "post:update") → true
  * @example matches("*:*", "anything:goes") → true
+ * @example matches("billing.*:read", "billing.invoice:read") → true
  * @example matches("post:read", "post:update") → false
  */
 export function matches(pattern, target) {
-    if (pattern === "*:*")
-        return true;
     const patternParsed = parsePermissionSafe(pattern);
     const targetParsed = parsePermissionSafe(target);
     if (!patternParsed || !targetParsed)
         return false;
-    const resourceMatch = patternParsed.resource === "*" ||
-        patternParsed.resource === targetParsed.resource;
-    const actionMatch = patternParsed.action === "*" ||
-        patternParsed.action === targetParsed.action;
-    return resourceMatch && actionMatch;
+    return matchesPermission(pattern, targetParsed);
 }
 /**
- * Check if a permission string matches a structured Permission object.
+ * Check if a permission pattern matches a structured Permission object.
  */
 export function matchesPermission(pattern, permission) {
     const parsed = parsePermissionSafe(pattern);
     if (!parsed)
         return false;
-    const resourceMatch = parsed.resource === "*" || parsed.resource === permission.resource;
-    const actionMatch = parsed.action === "*" || parsed.action === permission.action;
-    return resourceMatch && actionMatch;
+    return (patternStrMatches(parsed.resource, permission.resource) &&
+        patternStrMatches(parsed.action, permission.action));
 }
 /**
  * Parse a permission string, returning null on invalid format instead of throwing.
  */
-function parsePermissionSafe(permission) {
+export function parsePermissionSafe(permission) {
     if (!PERMISSION_REGEX.test(permission))
         return null;
     const lastColon = permission.lastIndexOf(":");
@@ -69,4 +73,8 @@ function parsePermissionSafe(permission) {
     const action = permission.slice(lastColon + 1);
     return { resource, action };
 }
+/** Build a permission string from a resource and an action. */
+export function formatPermission(resource, action) {
+    return `${resource}:${action}`;
+}
 //# sourceMappingURL=permission.core.js.map

package/dist/permission/permissionRegistry.d.ts

@@ -5,7 +5,8 @@
  */
 import type { Permission } from "../permissionTypes/index.js";
 /** A registered permission with optional metadata. */
-interface RegisteredPermission {
+export interface RegisteredPermission {
+    readonly key: string;
     readonly parsed: Permission;
     readonly description?: string;
     readonly implies?: readonly string[];
@@ -15,49 +16,42 @@ export interface PermissionRegistryOptions {
     /** Allow overwriting existing permissions. Defaults to false. */
     readonly allowOverride?: boolean;
 }
-/**
- * Create a permission registry.
- */
-export declare function createPermissionRegistry(options?: PermissionRegistryOptions): {
-    /**
-     * Register a permission by string or structured object.
-     */
-    define(permission: string | Permission, opts?: {
+/** A registry of the permissions an application defines. */
+export interface PermissionRegistry {
+    define(permission: string | Permission, options?: {
         readonly description?: string;
         readonly implies?: readonly string[];
     }): void;
-    /**
-     * Look up a registered permission by string.
-     */
     get(permission: string): Permission | undefined;
-    /**
-     * Get the full registered permission entry.
-     */
+    /** Like {@link PermissionRegistry.get}, but throws when unregistered. */
+    require(permission: string): Permission;
     getEntry(permission: string): RegisteredPermission | undefined;
-    /**
-     * Check if a permission is registered.
-     */
     has(permission: string): boolean;
-    /**
-     * Get all registered permission strings.
-     */
     all(): readonly string[];
-    /**
-     * Get permissions that match a pattern.
-     */
     match(pattern: string): readonly Permission[];
-    /**
-     * Get permissions implied by a given permission.
-     */
     getImplied(permission: string): readonly string[];
     /**
-     * Remove a permission from the registry.
+     * Every permission implied by `permission`, following chains and stopping
+     * at cycles. This is what `createPermissionEngine({ expandImplied })`
+     * wants: `post:admin implies post:read` only affects a decision if
+     * something expands it.
      */
+    expandImplied(permission: string): readonly string[];
     remove(permission: string): boolean;
-    /**
-     * Clear all registered permissions.
-     */
     clear(): void;
-};
-export {};
+}
+/**
+ * Create a permission registry.
+ *
+ * ```ts
+ * const permissions = createPermissionRegistry();
+ * permissions.define("post:admin", { implies: ["post:read", "post:write"] });
+ *
+ * const engine = createPermissionEngine({
+ *   roles,
+ *   expandImplied: (permission) => permissions.expandImplied(permission),
+ * });
+ * ```
+ */
+export declare function createPermissionRegistry(options?: PermissionRegistryOptions): PermissionRegistry;
 //# sourceMappingURL=permissionRegistry.d.ts.map

package/dist/permission/permissionRegistry.js

@@ -3,83 +3,101 @@
  *
  * @module permission/permissionRegistry
  */
-import { DuplicatePermissionError, PermissionNotFoundError, } from "../permissionErrors/index.js";
-import { parsePermission, matchesPermission } from "./permission.core.js";
+import { DuplicatePermissionError, InvalidPermissionError, PermissionNotFoundError, } from "../permissionErrors/index.js";
+import { formatPermission, isValidPermission, matchesPermission, parsePermission, } from "./permission.core.js";
 /**
  * Create a permission registry.
+ *
+ * ```ts
+ * const permissions = createPermissionRegistry();
+ * permissions.define("post:admin", { implies: ["post:read", "post:write"] });
+ *
+ * const engine = createPermissionEngine({
+ *   roles,
+ *   expandImplied: (permission) => permissions.expandImplied(permission),
+ * });
+ * ```
  */
 export function createPermissionRegistry(options) {
     const permissions = new Map();
     const allowOverride = options?.allowOverride ?? false;
+    function keyOf(permission) {
+        if (typeof permission === "string") {
+            // Validate strings and structured values alike; a structured value
+            // skipping validation let `{ resource: "a b", action: "" }` in.
+            parsePermission(permission);
+            return permission;
+        }
+        const key = formatPermission(permission.resource, permission.action);
+        if (!isValidPermission(key))
+            throw new InvalidPermissionError(key);
+        return key;
+    }
     return {
-        /**
-         * Register a permission by string or structured object.
-         */
-        define(permission, opts) {
-            const parsed = typeof permission === "string"
-                ? parsePermission(permission)
-                : permission;
-            const key = `${parsed.resource}:${parsed.action}`;
+        define(permission, defineOptions) {
+            const key = keyOf(permission);
+            const parsed = parsePermission(key);
             if (permissions.has(key) && !allowOverride) {
                 throw new DuplicatePermissionError(key);
             }
+            for (const implied of defineOptions?.implies ?? []) {
+                if (!isValidPermission(implied)) {
+                    throw new InvalidPermissionError(implied);
+                }
+            }
             permissions.set(key, {
-                parsed: Object.freeze(parsed),
-                description: opts?.description,
-                implies: opts?.implies,
+                key,
+                parsed,
+                description: defineOptions?.description,
+                implies: defineOptions?.implies
+                    ? Object.freeze([...defineOptions.implies])
+                    : undefined,
             });
         },
-        /**
-         * Look up a registered permission by string.
-         */
         get(permission) {
             return permissions.get(permission)?.parsed;
         },
-        /**
-         * Get the full registered permission entry.
-         */
+        require(permission) {
+            const entry = permissions.get(permission);
+            if (!entry)
+                throw new PermissionNotFoundError(permission);
+            return entry.parsed;
+        },
         getEntry(permission) {
             return permissions.get(permission);
         },
-        /**
-         * Check if a permission is registered.
-         */
         has(permission) {
             return permissions.has(permission);
         },
-        /**
-         * Get all registered permission strings.
-         */
         all() {
-            return Array.from(permissions.keys());
+            return [...permissions.keys()];
         },
-        /**
-         * Get permissions that match a pattern.
-         */
         match(pattern) {
             const results = [];
-            for (const [, entry] of permissions) {
-                if (matchesPermission(pattern, entry.parsed)) {
+            for (const entry of permissions.values()) {
+                if (matchesPermission(pattern, entry.parsed))
                     results.push(entry.parsed);
-                }
             }
             return results;
         },
-        /**
-         * Get permissions implied by a given permission.
-         */
         getImplied(permission) {
             return permissions.get(permission)?.implies ?? [];
         },
-        /**
-         * Remove a permission from the registry.
-         */
+        expandImplied(permission) {
+            const expanded = new Set();
+            const queue = [...(permissions.get(permission)?.implies ?? [])];
+            while (queue.length > 0) {
+                const next = queue.shift();
+                if (next === permission || expanded.has(next))
+                    continue;
+                expanded.add(next);
+                queue.push(...(permissions.get(next)?.implies ?? []));
+            }
+            return [...expanded];
+        },
         remove(permission) {
             return permissions.delete(permission);
         },
-        /**
-         * Clear all registered permissions.
-         */
         clear() {
             permissions.clear();
         },

package/dist/permissionErrors/index.d.ts

@@ -4,5 +4,5 @@
  * @module permissionErrors
  */
 export { PermissionError } from "./permissionError.base.js";
-export { PermissionDeniedError, PermissionNotFoundError, DuplicatePermissionError, RoleNotFoundError, DuplicateRoleError, InvalidPermissionError, InvalidRoleError, CircularRoleInheritanceError, PolicyError, PolicyTimeoutError, PermissionResolverError, AuthorizationAbortedError, } from "./permissionError.types.js";
+export { PermissionDeniedError, PermissionNotFoundError, DuplicatePermissionError, RoleNotFoundError, DuplicateRoleError, DuplicatePolicyError, InvalidPermissionError, InvalidRoleError, CircularRoleInheritanceError, PolicyError, PolicyTimeoutError, PermissionResolverError, AuthorizationAbortedError, } from "./permissionError.types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/permissionErrors/index.js

@@ -4,5 +4,5 @@
  * @module permissionErrors
  */
 export { PermissionError } from "./permissionError.base.js";
-export { PermissionDeniedError, PermissionNotFoundError, DuplicatePermissionError, RoleNotFoundError, DuplicateRoleError, InvalidPermissionError, InvalidRoleError, CircularRoleInheritanceError, PolicyError, PolicyTimeoutError, PermissionResolverError, AuthorizationAbortedError, } from "./permissionError.types.js";
+export { PermissionDeniedError, PermissionNotFoundError, DuplicatePermissionError, RoleNotFoundError, DuplicateRoleError, DuplicatePolicyError, InvalidPermissionError, InvalidRoleError, CircularRoleInheritanceError, PolicyError, PolicyTimeoutError, PermissionResolverError, AuthorizationAbortedError, } from "./permissionError.types.js";
 //# sourceMappingURL=index.js.map