permdock 0.4.0 → 0.5.0

package/dist/permdock-D7eeLJER.d.ts

@@ -0,0 +1,502 @@
+import { $n as Delegation, Bn as LimitDetail, G as CustomRoleSourceFactory, Hn as Obligation, J as EntitlementSource, Nn as Decision, Q as LimitStore, Rn as ExplainedDecision, Rt as Instant, T as Policy, Un as Quota, Vt as Snapshot, W as CustomRoleSource, Xt as DecisionEvent, _ as GrantLimit, at as SettingsSource, cn as Scope, et as MembershipSource, h as Grant, i as ApprovalOption, ir as Subject, it as RelationSource, j as PolicyVocabulary, lr as Condition, nr as Membership, q as DecisionSink, qn as Actor, qt as AuthEvent, rr as Principal, sr as AdapterId, ut as TokenSigner } from "./policy-types-DzwivBgR.js";
+import { N as ResourceNode, V as AppData, a as RoleTree, n as PlanTree, r as Role, w as Permission } from "./vocabulary-D6lPdb4Z.js";
+import { i as OperationEffect, s as OperationMeta, t as Operation, u as OperationRisk } from "./operations-CxybZErY.js";
+import { i as HostedPolicies } from "./hosted-DBDX0M-P.js";
+//#region src/core/approval-policies.d.ts
+/**
+ * One approval requirement kept as data, for a tenant or the whole platform.
+ * It adds to what the code requires and never removes a requirement.
+ */
+type ApprovalPolicy = {
+  /**
+   * The permission key; a former key from `renamed` resolves. Absent: every
+   * permission, which needs `risk` or `effects`.
+   */
+  readonly permission?: string;
+  /** Matches an operation call whose `meta.risk` is one of these; a call that names no operation never matches. */
+  readonly risk?: readonly OperationRisk[];
+  /** Matches an operation call whose `meta.effects` includes one of these; a call that names no operation never matches. */
+  readonly effects?: readonly OperationEffect[];
+  /** Absent: every tenant. */
+  readonly tenant?: string;
+  /** Actor kinds it applies to (`['agent']`); absent: every call. A call without an actor never matches a list. */
+  readonly actors?: readonly string[];
+  /** A portable condition over the row; instance permissions only, since a collection action has no row. */
+  readonly where?: Condition;
+  /** A portable condition over the call's input (the proposed row). */
+  readonly check?: Condition;
+  /**
+   * The same shape as `allow(..., { approval })`. An `escalation` here widens
+   * only this entry's stages, never the code's.
+   */
+  readonly approval: ApprovalOption;
+};
+/**
+ * Data-driven approval requirements, a subject input like `CustomRoleSource`:
+ * read once per instance for the subject's tenants (entries without a
+ * tenant always apply). A throw, a rejected promise or an invalid entry
+ * denies every call an allow would otherwise permit.
+ */
+type ApprovalPolicySource = {
+  /** Names the implementation in errors and events. */
+  readonly name?: string;
+  approvalPoliciesFor(query: {
+    readonly tenants: readonly string[];
+  }): readonly ApprovalPolicy[] | Promise<readonly ApprovalPolicy[]>;
+};
+/** The denial detail when an `ApprovalPolicySource` fails: every call an allow would grant denies with reason `approval`. */
+/**
+ * The in-process `ApprovalPolicySource`, usable directly as the
+ * `approvalPolicies` option: it is the source and its feature at once.
+ */
+declare function memoryApprovalPolicySource(policies: readonly ApprovalPolicy[]): ApprovalPolicySource & ApprovalPolicies;
+/** An entry checked against the policy and ready to match. */
+type LoadedApprovalPolicy = {
+  readonly permission?: string;
+  readonly risk?: ReadonlySet<OperationRisk>;
+  readonly effects?: ReadonlySet<OperationEffect>;
+  readonly tenant?: string;
+  readonly actors?: ReadonlySet<string>;
+  readonly where?: Condition;
+  readonly check?: Condition;
+  readonly approval: NonNullable<Grant["approval"]>;
+};
+/** `"failed"`: the source threw or returned something that cannot be applied. */
+/** What `tightenApproval` reads besides the code's approval. */
+type TightenInput = Parameters<typeof tightenApproval>[2];
+/**
+ * Approval policies loaded for an instance: the tightening the evaluator
+ * applies to each allow, or `"failed"` when the source threw or returned an
+ * invalid entry (every allow then denies).
+ */
+type LoadedApprovalPolicies = {
+  readonly tighten: (code: Grant["approval"], input: TightenInput) => Grant["approval"];
+} | "failed";
+/**
+ * Approval policies kept as data, as an instance option:
+ * `approvalPolicies: approvalPolicies(source)`. The loading and tightening
+ * code ships only with an app that imports this function.
+ */
+type ApprovalPolicies = {
+  readonly feature: "approval-policies";
+  readonly load: (policy: Policy, tenants: readonly string[], auth: AuthEvent[]) => LoadedApprovalPolicies | Promise<LoadedApprovalPolicies>;
+};
+declare function approvalPolicies(source: ApprovalPolicySource): ApprovalPolicies;
+/**
+ * Why an `ApprovalPolicy` entry does not load. `unknown-permission`: the
+ * policy declares no such key (the entry applies to nothing). `invalid`: a
+ * field has the wrong shape or the approval option does not normalise.
+ * `where-on-collection`: `where` reads a row, which a collection action
+ * never has, so the entry could never match; use `check` over the input.
+ * `stale-on-without-version`: `staleOn` needs an instance permission whose
+ * resource declares `version`.
+ */
+type ApprovalPolicyProblem = "unknown-permission" | "invalid" | "where-on-collection" | "stale-on-without-version";
+type ApprovalPolicyValidation = {
+  readonly ok: true;
+} | {
+  readonly ok: false;
+  readonly problem: ApprovalPolicyProblem;
+};
+/**
+ * Checks one entry against the policy the way `approvalPoliciesFor` loads
+ * it, for an application to refuse a bad entry when it is saved instead of
+ * finding every call denied. Never throws.
+ */
+declare function validateApprovalPolicy(policy: Policy, entry: unknown): ApprovalPolicyValidation;
+/**
+ * `code` with every matching entry added as further stages: the result
+ * needs all of them (`'sequential'` when any part is ordered), keeps the
+ * code's escalation, the shortest `ttl`, and `distinct` unless every part
+ * opts out. Without a matching entry, `code` unchanged.
+ */
+declare function tightenApproval(code: Grant["approval"], entries: readonly LoadedApprovalPolicy[], input: {
+  readonly permission: string;
+  readonly tenant: string | undefined;
+  readonly subject: Subject;
+  readonly current: unknown;
+  readonly next: unknown;
+  readonly now: number;
+  readonly scopes: readonly Scope[];
+  /** The meta of the operation the call decides, when it names one. */
+  readonly operation?: OperationMeta | undefined;
+}): Grant["approval"];
+//#endregion
+//#region src/core/limits.d.ts
+declare function memoryLimitStore(): LimitStore & {
+  /** Live counters, for tests and diagnostics. */
+  size(): number;
+};
+type QuotaVerdict = {
+  readonly ok: true;
+  readonly quota?: Quota;
+  readonly obligations?: readonly Obligation[];
+} | {
+  readonly ok: false;
+  readonly reason: "limit";
+  readonly detail: LimitDetail;
+} | {
+  readonly ok: false;
+  readonly reason: "limit-unavailable";
+};
+/** What the quota stage of `evaluate` asks about one allow whose grant has a `limit`. */
+type QuotaInput = {
+  readonly cache: Map<string, number>;
+  readonly limit: GrantLimit;
+  readonly permissionKey: string;
+  readonly subjectId: string;
+  readonly tenant: string | undefined;
+  readonly now: number;
+  readonly consume: boolean;
+};
+/**
+ * Grant limits as an instance option: `limits: limits(store)`. The counting
+ * code ships only with an app that imports this function; without it, a grant
+ * with a `limit` denies with `limit-unavailable`.
+ */
+type Limits = {
+  readonly feature: "limits";
+  readonly quota: (input: QuotaInput) => QuotaVerdict;
+};
+declare function limits(store: LimitStore): Limits;
+//#endregion
+//#region src/core/may-use.d.ts
+type PermittedIdsOptions = {
+  readonly within?: string;
+  readonly conditioned?: boolean;
+};
+//#endregion
+//#region src/core/principal-source.d.ts
+/**
+ * An identity the application has linked to one of its principals: an email
+ * address or a chat platform user.
+ */
+type PrincipalIdentity = {
+  readonly kind: "email" | "chat";
+  /** The chat platform (`slack`, `teams`, …); absent for email. */
+  readonly provider?: string;
+  /** The address (RFC 5322 `addr-spec`) or the platform user id. Emails compare trimmed and case-insensitively. */
+  readonly value: string;
+  /** The chat workspace or team id. */
+  readonly workspace?: string;
+};
+/**
+ * Live principals by id, a subject input like `MembershipSource`. `null`, a
+ * throw or a rejection is no principal, and so is a missing
+ * `principalByIdentity`: every reader fails closed.
+ */
+type PrincipalSource<TPrincipal extends Principal = Principal> = {
+  /** Names the implementation in errors and events. */
+  readonly name?: string;
+  /** The principal as of this request, or `null` for one deleted, suspended or unknown. */
+  principal(id: string, options?: {
+    readonly tenant?: string;
+  }): TPrincipal | null | Promise<TPrincipal | null>;
+  /** The principal an app-owned identity link points to, or `null` when none does. */
+  principalByIdentity?(identity: PrincipalIdentity): TPrincipal | null | Promise<TPrincipal | null>;
+};
+/** One `memoryPrincipalSource` identity link: `identity` resolves to the principal with id `principal`. */
+type PrincipalIdentityLink = {
+  readonly identity: PrincipalIdentity;
+  readonly principal: string;
+};
+/**
+ * In-process principals for tests and single-replica apps. `identities`
+ * links an email or chat identity to a principal id; each answer is a fresh
+ * frozen copy. `tenant` is not a filter, as for a database source.
+ */
+declare function memoryPrincipalSource<TPrincipal extends Principal>(input: {
+  readonly principals: readonly TPrincipal[];
+  readonly identities?: readonly PrincipalIdentityLink[];
+}): PrincipalSource<TPrincipal> & {
+  principalByIdentity(identity: PrincipalIdentity): TPrincipal | null;
+};
+//#endregion
+//#region src/core/validation.d.ts
+type Boundary = "http-body" | "mcp-args" | "tool-args" | "decision-endpoint" | "manual";
+//#endregion
+//#region src/core/permdock.d.ts
+type DecideOptions = {
+  /** `true` skips schema validation for a row the server loaded itself. Otherwise `data` is validated against the resource schema first (`validate: 'boundary'`), and a failure denies with reason `validation`. */
+  readonly trusted?: boolean;
+  /** Where untrusted data came from, reported on validation errors. Defaults to `'manual'`. */
+  readonly boundary?: Boundary;
+  /** Decision clock, for expiries and limits; a `Temporal.Instant` fits. Defaults to the current time. */
+  readonly now?: Instant;
+  /** The call that produced the decision, reported on the decision event. Defaults to `'decide'`. */
+  readonly call?: DecisionEvent["call"];
+  /** The adapter that made the call, reported on the decision event. */
+  readonly adapter?: AdapterId;
+  /** The model id the decision is about or that drove the call (`'openai/gpt-5'`), reported on the decision event. Never read when deciding. */
+  readonly model?: string;
+  /** Per-call unauthorized handler for `assert`; runs before instance and policy handlers. */
+  readonly onDenied?: (decision: Decision) => never | void;
+  /** The field being read or written; only grants whose `fields` cover it match. */
+  readonly field?: string;
+  /** `true` attaches a `trace` to the decision: the grants evaluated, matched and skipped. Off by default and free when off. */
+  readonly explain?: boolean;
+  /**
+   * A declared scope name: only memberships of that scope answer the check.
+   * Naming the first scope keeps nested memberships out of a tenant-level
+   * guard on a collection action. Global roles still apply; resource roles
+   * and memberships of other scopes are skipped with reason `scope`.
+   */
+  readonly scope?: string;
+  /**
+   * The operation the call decides, for `ApprovalPolicySource` entries that
+   * match on `meta.risk` and `meta.effects`. Surfaces that decide an
+   * operation (agent tools, workflow steps, `protect(operation)`) pass it.
+   */
+  readonly operation?: Pick<Operation, "name" | "meta">;
+  /**
+   * The arguments of the call being decided, such as a tool call's input. An
+   * `approval-required` token binds their digest, so an approval covers this
+   * call and no call with other arguments. Agent and MCP adapters pass the
+   * tool arguments. Never read when deciding.
+   */
+  readonly args?: unknown;
+  /**
+   * The application's own data for the decision event (a request id, a
+   * route). Plain JSON; a value that is not is dropped. Never read when
+   * deciding.
+   */
+  readonly x?: AppData;
+};
+type SimulateOptions = {
+  /** Decision clock for the whole batch: grant validity, membership expiry and limits are read as of this instant. Defaults to the current time. */
+  readonly now?: Instant;
+};
+type RowPair<T> = {
+  readonly current: T;
+  readonly next: T;
+};
+type WhereResult = {
+  readonly condition: Condition | {
+    readonly op: "or";
+    readonly conditions: readonly [];
+  };
+  readonly partial: boolean;
+  /**
+   * The subject `where()` was built for. `toWhere` reads its memberships for
+   * `memberOf` when no `subject` option is passed. Not enumerable, so it never
+   * serialises with the result.
+   */
+  readonly subject?: Subject;
+  /** The policy's scopes, for `memberOf`; not enumerable either. */
+  readonly scopes?: readonly Scope[];
+  /** The policy's resource graph, for `related`; not enumerable either. */
+  readonly resources?: ReadonlyMap<string, ResourceNode>;
+};
+type SnapshotOptions = {
+  readonly include?: readonly (Permission | {
+    readonly [key: string]: unknown;
+  })[];
+  readonly tenants?: "all";
+  readonly signer?: TokenSigner;
+  readonly audience?: string | readonly string[];
+};
+type PermDock<V extends PolicyVocabulary = PolicyVocabulary> = {
+  readonly can: {
+    (permission: Permission<string, unknown, "instance">, data: unknown, options?: DecideOptions): boolean;
+    (permission: Permission<string, unknown, "collection">, data?: unknown, options?: DecideOptions): boolean;
+    /**
+     * A permission held as `Permission` at run time (from a list, a catalog
+     * or `findPermission`), whose kind the type does not say: pass `data`,
+     * or `undefined` for a check without a row.
+     */
+    (permission: Permission, data: unknown, options?: DecideOptions): boolean;
+  };
+  readonly decide: {
+    (permission: Permission<string, unknown, "instance">, data: unknown, options?: DecideOptions): Decision;
+    (permission: Permission<string, unknown, "collection">, data?: unknown, options?: DecideOptions): Decision;
+    /**
+     * A permission held as `Permission` at run time (from a list, a catalog
+     * or `findPermission`), whose kind the type does not say: pass `data`,
+     * or `undefined` for a check without a row.
+     */
+    (permission: Permission, data: unknown, options?: DecideOptions): Decision;
+  };
+  /**
+   * `decide` for each row, in row order. Each row is its own call: a limit
+   * is consumed once per granted row, so rows past the cap are denied with
+   * `limit`, and each `approval-required` row carries its own token.
+   */
+  readonly decideEach: (permission: Permission, rows: readonly unknown[], options?: DecideOptions) => readonly Decision[];
+  /**
+   * What `permission` on `row` decides for the principal `principalId`,
+   * loaded from `principals` in this instance's active tenant with no actor
+   * and no delegation. It grants this instance nothing, shares none of its
+   * caches and never consumes a limit. Denied with `anonymous` when there is
+   * no `principals`, no such principal or the source throws, and with
+   * `tenant-mismatch` when the principal is outside the active tenant.
+   */
+  readonly decideFor: (principalId: string, permission: Permission, row?: unknown) => Promise<Decision>;
+  readonly assert: {
+    (permission: Permission<string, unknown, "instance">, data: unknown, options?: DecideOptions): Extract<Decision, {
+      readonly outcome: "granted";
+    }>;
+    (permission: Permission<string, unknown, "collection">, data?: unknown, options?: DecideOptions): Extract<Decision, {
+      readonly outcome: "granted";
+    }>;
+    /**
+     * A permission held as `Permission` at run time (from a list, a catalog
+     * or `findPermission`), whose kind the type does not say: pass `data`,
+     * or `undefined` for a check without a row.
+     */
+    (permission: Permission, data: unknown, options?: DecideOptions): Extract<Decision, {
+      readonly outcome: "granted";
+    }>;
+  };
+  /**
+   * `decide` with `explain: true`: the same decision, with a `trace` that
+   * names the grants evaluated, the allows and denies that matched (so a
+   * `denied` says which deny won) and the grants passed over. Local
+   * computation only; the trace never reaches a `DecisionSink`.
+   */
+  readonly explain: {
+    (permission: Permission<string, unknown, "instance">, data: unknown, options?: Omit<DecideOptions, "explain">): ExplainedDecision;
+    (permission: Permission<string, unknown, "collection">, data?: unknown, options?: Omit<DecideOptions, "explain">): ExplainedDecision;
+    (permission: Permission, data: unknown, options?: Omit<DecideOptions, "explain">): ExplainedDecision;
+  };
+  readonly filter: <T>(permission: Permission<string, T, "instance">, rows: readonly T[], options?: DecideOptions) => T[];
+  readonly pick: <T>(permission: Permission<string, T, "instance">, row: T, options?: DecideOptions) => Partial<T>;
+  readonly where: (permission: Permission) => WhereResult;
+  readonly actions: (resource: Permission | {
+    readonly [key: string]: unknown;
+  }, data: unknown, options?: DecideOptions) => Permission[];
+  readonly simulate: {
+    (checks: readonly (readonly [Permission, unknown?])[], options?: SimulateOptions): Decision[];
+    (preview: {
+      readonly roles?: readonly (string | Role)[];
+      readonly memberships?: readonly Membership[];
+      readonly tenant?: string;
+    }): PermDock<V>;
+  };
+  readonly snapshot: {
+    (options?: SnapshotOptions & {
+      readonly signer?: undefined;
+    }): Snapshot;
+    (options: SnapshotOptions & {
+      readonly signer: TokenSigner;
+    }): Promise<string>;
+    (options?: SnapshotOptions): Snapshot | Promise<string>;
+  };
+  readonly on: (event: "decision" | "denied" | "approval" | "auth" | "error", handler: (payload: unknown) => void) => () => void;
+  readonly tenant: (id: string) => PermDock<V>;
+  readonly team: (id: string) => PermDock<V>;
+  readonly memberships: () => readonly Membership[];
+  readonly tenants: () => readonly string[];
+  /**
+   * Roles held in a tenant (the active one by default), or only on the
+   * memberships of one `scope` (and instance `id`). Ordered by rank: a role
+   * comes before the roles its `assigns` lists.
+   */
+  readonly heldRoles: (options?: {
+    readonly tenant?: string;
+    readonly scope?: string;
+    readonly id?: string;
+  }) => readonly Role[];
+  /** The distinct `meta.audience` values of the roles held in the active tenant, in rank order. */
+  readonly audiences: () => readonly string[];
+  /**
+   * The roles the subject may hand out in a tenant (the active one by
+   * default), or with `scope: 'global'` the global roles it may hand out. A
+   * snapshot answers only the tenant form.
+   */
+  readonly assignableRoles: (options?: {
+    readonly tenant?: string;
+    readonly scope?: "global";
+  }) => readonly Role[];
+  /**
+   * The custom-role ceiling the subject may hand out: in a tenant (empty
+   * without one), or with `scope: 'global'` for platform custom roles, the
+   * allows of assignable global roles the subject holds. A snapshot answers
+   * only the tenant form.
+   */
+  readonly assignablePermissions: (options?: {
+    readonly tenant?: string;
+    readonly scope?: "global";
+  }) => readonly Permission[];
+  /**
+   * The levels of `permission` (`resource(…, { levels })`) the subject may
+   * hand out in a custom role: those it holds, or every level with
+   * `meta.manageRoles`. Empty when the permission is not assignable.
+   */
+  readonly assignableLevels: (permission: Permission, options?: {
+    readonly tenant?: string;
+    readonly scope?: "global";
+  }) => readonly string[];
+  /**
+   * Whether `permission` could be granted to the subject for some row, within
+   * its delegation. A listing hint for tools and skills, never a decision.
+   */
+  readonly mayUse: (permission: Permission) => boolean;
+  /**
+   * The instances of `scope` in which the subject holds `permission`, the
+   * in-process mirror of the SQL `permitted_<scope>_ids_by_permission`. A
+   * listing, never a decision: a row's own check still runs `can`.
+   */
+  readonly permittedIds: (permission: Permission, scope: string, options?: PermittedIdsOptions) => readonly string[];
+  /**
+   * Loads the relation facts `permission` needs for `rows` into this
+   * instance's cache, so `can`, `decide` and `filter` answer synchronously
+   * over an async `RelationSource`. It never grants; a failed load leaves
+   * the checks denied with `relation-unavailable`.
+   */
+  readonly prefetchRelations: (permission: Permission, rows: readonly unknown[]) => Promise<void>;
+  readonly roles: V["roles"] extends RoleTree ? V["roles"] : RoleTree;
+  readonly plans: V["plans"] extends PlanTree ? V["plans"] : PlanTree;
+  readonly permissions: V["permissions"] extends Policy["permissions"] ? V["permissions"] : Policy["permissions"];
+  readonly subject: Subject;
+  /**
+   * The same subject, tenant, team, actor, delegation, sink and limits with
+   * other sources: `customRoles`, `approvalPolicies` or `relations`. The
+   * sources it names are read again for the subject's tenants; the others
+   * keep what this instance loaded. Always a promise, since the sources it
+   * names may answer asynchronously.
+   */
+  readonly derive: (options: DeriveOptions) => Promise<PermDock<V>>;
+};
+/** What `permdock.derive` may replace: the sources read after the subject is resolved. */
+type DeriveOptions = Pick<PermDockOptions, "customRoles" | "approvalPolicies" | "relations" | "principals">;
+type PermDockOptions = {
+  readonly tenant?: string;
+  /** One source, or several composed with `composeMemberships`. */
+  readonly memberships?: MembershipSource | readonly MembershipSource[];
+  readonly customRoles?: CustomRoleSource | CustomRoleSourceFactory;
+  /** Plans and seats from billing, merged into `principal.plans` for the active tenant. */
+  readonly entitlements?: EntitlementSource;
+  readonly actor?: Actor;
+  readonly delegation?: Delegation;
+  readonly sink?: DecisionSink;
+  /** Grant limits, `limits(store)`; without it a grant with a `limit` denies with `limit-unavailable`. */
+  readonly limits?: Limits;
+  readonly session?: string;
+  readonly expiresAt?: number;
+  /** Hosted grants, `hostedPolicies(source)`; `current()` is read once, when the instance is created. */
+  readonly policies?: HostedPolicies;
+  /** The object graph for `through` and edge-table relations; without it they deny with `relation-unavailable`. */
+  readonly relations?: RelationSource;
+  /** Approval requirements kept as data; they add to the code's and never remove one. A throw denies. */
+  readonly approvalPolicies?: ApprovalPolicies;
+  /** Other principals by id, for `decideFor`; asked with the active tenant. */
+  readonly principals?: PrincipalSource;
+  /** Tenant settings, read by `decideCredential` for the key's tenant; a call's own `settings` wins. */
+  readonly settings?: SettingsSource;
+  /**
+   * Request values an adapter's `context` hook derived on the server, merged
+   * into `subject.context`; keys from `policy.context` win on a clash.
+   */
+  readonly context?: Readonly<Record<string, unknown>>;
+};
+/**
+ * The instance for `user`, built synchronously. Every input must answer
+ * synchronously: the subject mapper, `memberships`, `customRoles`,
+ * `entitlements`, `approvalPolicies` and the freshness check. One that
+ * answers with a Promise throws here; use `getPermDock` for those.
+ */
+declare function getPermDockSync<TUser, TPrincipal extends Principal = Principal, V extends PolicyVocabulary = PolicyVocabulary>(policy: Policy<TUser, TPrincipal, V>, user: TUser | Subject | null, options?: PermDockOptions): PermDock<V>;
+/** The instance for `user`: waits for every source, then builds it. `getPermDockSync` is the synchronous twin. */
+declare function getPermDock<TUser, TPrincipal extends Principal = Principal, V extends PolicyVocabulary = PolicyVocabulary>(policy: Policy<TUser, TPrincipal, V>, user: TUser | Subject | null, options?: PermDockOptions): Promise<PermDock<V>>;
+//#endregion
+export { ApprovalPolicyValidation as C, validateApprovalPolicy as E, ApprovalPolicySource as S, memoryApprovalPolicySource as T, limits as _, RowPair as a, ApprovalPolicy as b, WhereResult as c, PrincipalIdentity as d, PrincipalIdentityLink as f, Limits as g, PermittedIdsOptions as h, PermDockOptions as i, getPermDock as l, memoryPrincipalSource as m, DeriveOptions as n, SimulateOptions as o, PrincipalSource as p, PermDock as r, SnapshotOptions as s, DecideOptions as t, getPermDockSync as u, memoryLimitStore as v, approvalPolicies as w, ApprovalPolicyProblem as x, ApprovalPolicies as y };

package/dist/{permission-registry-BsblpB-z.js → permission-registry-Br4jSNVi.js}

@@ -1,8 +1,8 @@
 import { n as isReadonlyArray, t as compact } from "./compact-CAf557ZB.js";
 import { n as freezeDeep } from "./freeze-CrU8nQeX.js";
-import { a as assertSafeKey, c as ownKeys, o as isForbiddenKey } from "./thenable-QSmvt-vZ.js";
-import { r as parseAppData, t as assertAppData } from "./app-data-CV8pqqMi.js";
-import { f as normaliseRelation, h as restrictedStopsOf, i as assertIncludes, n as RESOURCE_NAME, r as assertGraphTargets, t as LEVEL_NAME } from "./resource-relations-D1Un3pcz.js";
+import { i as ownKeys, n as isForbiddenKey, t as assertSafeKey } from "./paths-DXSHAMIa.js";
+import { r as parseAppData, t as assertAppData } from "./app-data-MuyzVqX8.js";
+import { f as normaliseRelation, h as restrictedStopsOf, i as assertIncludes, n as RESOURCE_NAME, r as assertGraphTargets, t as LEVEL_NAME } from "./resource-relations-D_jw0BFx.js";
 //#region src/core/brands.ts
 const RESOURCE_BRAND = Symbol.for("permdock.resource");
 const TREE_REGISTRY = Symbol.for("permdock.registry");

package/dist/permissions-B-wCP5ZC.js

@@ -0,0 +1,30 @@
+import { n as freezeDeep } from "./freeze-CrU8nQeX.js";
+import { d as attachRegistry, p as walk, r as formerByKey, t as assertKeys } from "./permission-registry-Br4jSNVi.js";
+import { r as assertGraphTargets } from "./resource-relations-D_jw0BFx.js";
+//#region src/core/operation-risks.ts
+/** Every `meta.risk` level, lowest first. */
+const OPERATION_RISKS = Object.freeze([
+	"low",
+	"medium",
+	"high",
+	"critical"
+]);
+function isOperationRisk(value) {
+	return OPERATION_RISKS.some((risk) => risk === value);
+}
+//#endregion
+//#region src/core/permissions.ts
+function definePermissions(input, options) {
+	const registry = /* @__PURE__ */ new Map();
+	const leaves = [];
+	const former = formerByKey(options?.renamed);
+	const tree = walk(input, [], registry, leaves, 0, {
+		former,
+		x: options?.x
+	});
+	assertKeys(leaves, former);
+	assertGraphTargets(registry);
+	return freezeDeep(attachRegistry(tree, registry, leaves));
+}
+//#endregion
+export { OPERATION_RISKS as n, isOperationRisk as r, definePermissions as t };

package/dist/{permissions-CCJ6lmxB.js → permissions-CZKiUfFM.js}

@@ -1,6 +1,7 @@
-import { i as crud, s as definePermissions } from "./src-Bb7no-hS.js";
-import { _ as resource } from "./permission-registry-BsblpB-z.js";
-import { f as definePlans, p as defineRoles } from "./grantee-CXY-0C87.js";
+import { i as crud } from "./src-DLfUWFAI.js";
+import { _ as resource } from "./permission-registry-Br4jSNVi.js";
+import { f as definePlans, p as defineRoles } from "./grantee-Cn1HyUsI.js";
+import { t as definePermissions } from "./permissions-B-wCP5ZC.js";
 //#region src/testing/saas/schema.ts
 function accepts(kind, value) {
 	switch (kind) {

package/dist/{permissions-COH-KRgT.d.ts → permissions-oEWfl-kl.d.ts}

@@ -1,5 +1,4 @@
-import { h as ResourceInit, u as InferPermissionTree } from "./permission-types-Dg39z9Kv.js";
-import { r as Role, t as Plan } from "./vocabulary-hhEFLFoL.js";
+import { C as InferPermissionTree, k as ResourceInit, r as Role, t as Plan } from "./vocabulary-D6lPdb4Z.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/testing/saas/permissions.d.ts
 declare const SaasProjectSchema: StandardSchemaV1<SaasProject>;