permdock 0.7.0 → 0.8.0

package/dist/{permdock-Dco6dyCK.d.ts → permdock-B6Sf4T_S.d.ts}

@@ -1,12 +1,12 @@
-import { G as CustomRoleSourceFactory, Gt as Snapshot, Hn as ExplainedDecision, J as EntitlementSource, Kn as Obligation, Ln as Decision, Q as LimitStore, Rt as Instant, T as Policy, W as CustomRoleSource, Wn as LimitDetail, Zn as Actor, Zt as AuthEvent, _ as GrantLimit, at as SettingsSource, en as DecisionEvent, et as MembershipSource, fn as Scope, fr as AdapterId, h as Grant, i as ApprovalOption, it as RelationSource, j as PolicyVocabulary, lr as Subject, mr as Condition, or as Membership, q as DecisionSink, qn as Quota, rr as Delegation, sr as Principal, ut as TokenSigner } from "./policy-types-B-F-qAZk.js";
-import { O as AppData, b as ResourceNode, u as Permission } from "./permission-types-DhNEmoRG.js";
-import { a as RoleTree, n as PlanTree, r as Role } from "./vocabulary-Bg3eeT2H.js";
-import { i as OperationEffect, s as OperationMeta, t as Operation, u as OperationRisk } from "./operations-BNLes61x.js";
-import { a as HostedPolicies } from "./hosted-BmjzxQhp.js";
+import { G as CustomRoleSourceFactory, Gt as Snapshot, Hn as ExplainedDecision, J as EntitlementSource, Kn as Obligation, Ln as Decision, Q as LimitStore, Rt as Instant, T as Policy, W as CustomRoleSource, Wn as LimitDetail, Zn as Actor, Zt as AuthEvent, _ as GrantLimit, at as SettingsSource, en as DecisionEvent, et as MembershipSource, fn as Scope, fr as AdapterId, h as Grant, i as ApprovalOption, it as RelationSource, j as PolicyVocabulary, lr as Subject, mr as Condition, or as Membership, q as DecisionSink, qn as Quota, rr as Delegation, sr as Principal, ut as TokenSigner } from "./policy-types-CCiDRZBH.js";
+import { D as RowOf, M as AppData, b as ResourceNode, u as Permission } from "./permission-types-CAY-GU7e.js";
+import { a as RoleTree, n as PlanTree, r as Role } from "./vocabulary-DEJ5j4mR.js";
+import { i as OperationEffect, s as OperationMeta, t as Operation, u as OperationRisk } from "./operations-Ci_rT6Uo.js";
+import { a as HostedPolicies } from "./hosted-Cmtxogd0.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.
+ * 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 = {
   /**
@@ -14,15 +14,27 @@ type ApprovalPolicy = {
    * 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. */
+  /**
+   * 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. */
+  /**
+   * 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. */
+  /**
+   * 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. */
+  /**
+   * 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;
@@ -34,18 +46,21 @@ type ApprovalPolicy = {
 };
 /**
  * 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.
+ * 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: {
+  approvalPoliciesFor: (query: {
     readonly tenants: readonly string[];
-  }): readonly ApprovalPolicy[] | Promise<readonly ApprovalPolicy[]>;
+  }) => readonly ApprovalPolicy[] | Promise<readonly ApprovalPolicy[]>;
 };
-/** The denial detail when an `ApprovalPolicySource` fails: every call an allow would grant denies with reason `approval`. */
+/**
+ * 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.
@@ -74,9 +89,9 @@ 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.
+ * 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";
@@ -84,11 +99,11 @@ type ApprovalPolicies = {
 };
 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.
+ * 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`.
  */
@@ -100,16 +115,16 @@ type ApprovalPolicyValidation = {
   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.
+ * 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.
+ * `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;
@@ -124,13 +139,16 @@ declare function tightenApproval(code: Grant["approval"], entries: readonly Load
 }): Grant["approval"];
 //#endregion
 //#region src/core/checks.d.ts
-/** One check of `canAll` or `decideAll`: a permission alone, or with the row it is checked on. */
+/**
+ * One check of `canAll` or `decideAll`: a permission alone, or with the row it
+ * is checked on.
+ */
 type PermissionCheck = Permission | readonly [permission: Permission, data?: unknown];
 //#endregion
 //#region src/core/limits.d.ts
 declare function memoryLimitStore(): LimitStore & {
   /** Live counters, for tests and diagnostics. */
-  size(): number;
+  size: () => number;
 };
 type QuotaVerdict = {
   readonly ok: true;
@@ -144,7 +162,10 @@ type QuotaVerdict = {
   readonly ok: false;
   readonly reason: "limit-unavailable";
 };
-/** What the quota stage of `evaluate` asks about one allow whose grant has a `limit`. */
+/**
+ * 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;
@@ -180,7 +201,10 @@ 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. */
+  /**
+   * 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;
@@ -193,94 +217,143 @@ type PrincipalIdentity = {
 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?: {
+  /**
+   * 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>;
+  }) => 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`. */
+/**
+ * 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.
+ * 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;
+  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
-/** Rows the server loaded for `decideIds`: by id, or a list carrying the resource id field. */
+/**
+ * Rows the server loaded for `decideIds`: by id, or a list carrying the
+ * resource id field.
+ */
 type LoadedRows = ReadonlyMap<string, unknown> | readonly unknown[];
 type DecideIdsOptions = Omit<DecideOptions, "trusted" | "boundary"> & {
   /** Loads the rows for `ids`; ids it leaves out are denied with `validation`. */
   readonly data: (ids: readonly string[]) => LoadedRows | Promise<LoadedRows>;
 };
 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`. */
+  /**
+   * `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'`. */
+  /**
+   * 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. */
+  /**
+   * 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'`. */
+  /**
+   * 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. */
+  /**
+   * 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. */
+  /**
+   * 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. */
+  /**
+   * `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`.
+   * 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.
+   * 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.
+   * 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.
+   * 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. */
+  /**
+   * 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;
 };
+/**
+ * The `data` a check of `P` takes: any part of its row, or a `{ current, next
+ * }` pair of them for an update. `RowOf` is `unknown` for an untyped
+ * permission, so any value passes.
+ */
+type RowData<P> = Partial<RowOf<P>> | RowPair<Partial<RowOf<P>>> | null | undefined;
+/**
+ * `data` the type system knows nothing about (`unknown`, `any`), such as a
+ * request body. The check parses it against the resource schema at run time; a
+ * value of a known type that does not fit the row is a type error.
+ */
+type UncheckedData<D> = D & (unknown extends D ? unknown : never);
 type WhereResult = {
   readonly condition: Condition | {
     readonly op: "or";
@@ -308,87 +381,111 @@ type SnapshotOptions = {
 };
 type PermDock<V extends PolicyVocabulary = PolicyVocabulary> = {
   readonly can: {
-    (permission: Permission<string, unknown, "instance">, data: unknown, options?: DecideOptions): boolean;
+    <P extends Permission<string, unknown, "instance">>(permission: P, data: RowData<P>, 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.
+     * Data of no known type (`unknown`, `any`), such as a request body. It is
+     * parsed against the resource schema at run time.
+     */
+    <D>(permission: Permission, data: UncheckedData<D>, 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;
+    <P extends Permission>(permission: P, data: RowData<P>, options?: DecideOptions): boolean;
   };
   readonly decide: {
-    (permission: Permission<string, unknown, "instance">, data: unknown, options?: DecideOptions): Decision;
+    <P extends Permission<string, unknown, "instance">>(permission: P, data: RowData<P>, 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.
+     * Data of no known type (`unknown`, `any`), such as a request body. It is
+     * parsed against the resource schema at run time.
      */
-    (permission: Permission, data: unknown, options?: DecideOptions): Decision;
+    <D>(permission: Permission, data: UncheckedData<D>, 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.
+     */
+    <P extends Permission>(permission: P, data: RowData<P>, options?: DecideOptions): Decision;
   };
   /**
-   * `can` for every check, on one instance: `true` only when each is
-   * granted, and `false` for an empty list. A check is a permission, or a
-   * `[permission, row]` pair. It stops at the first check that is not granted.
+   * `can` for every check, on one instance: `true` only when each is granted,
+   * and `false` for an empty list. A check is a permission, or a `[permission,
+   * row]` pair. It stops at the first check that is not granted.
    */
   readonly canAll: (checks: readonly PermissionCheck[], options?: DecideOptions) => boolean;
-  /** `decide` for every check, in check order; a check is a permission or a `[permission, row]` pair. */
+  /**
+   * `decide` for every check, in check order; a check is a permission or a
+   * `[permission, row]` pair.
+   */
   readonly decideAll: (checks: readonly PermissionCheck[], options?: DecideOptions) => readonly 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
+   * `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[];
+  readonly decideEach: {
+    <D>(permission: Permission, rows: readonly UncheckedData<D>[], options?: DecideOptions): readonly Decision[];
+    <P extends Permission>(permission: P, rows: readonly RowData<P>[], options?: DecideOptions): readonly Decision[];
+  };
   /**
    * `decide` for each id, in id order, on rows the server loads itself:
    * `options.data(ids)` answers a map from id to row, or the rows with their
-   * resource id field. Each row is trusted (no schema check) and decided in
-   * the tenant its own root scope field names, as `permdock.tenant(<that
-   * value>)` would, so one call can span tenants. An id with no loaded row,
-   * a loader that throws and a row of another resource are denied with
-   * `validation`. A snapshot instance denies every id with `unsupported`.
+   * resource id field. Each row is trusted (no schema check) and decided in the
+   * tenant its own root scope field names, as `permdock.tenant(<that value>)`
+   * would, so one call can span tenants. An id with no loaded row, a loader
+   * that throws and a row of another resource are denied with `validation`. A
+   * snapshot instance denies every id with `unsupported`.
    */
   readonly decideIds: (permission: Permission, ids: readonly string[], options: DecideIdsOptions) => Promise<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
+   * 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, {
+    <P extends Permission<string, unknown, "instance">>(permission: P, data: RowData<P>, 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.
+     * Data of no known type (`unknown`, `any`), such as a request body. It is
+     * parsed against the resource schema at run time.
+     */
+    <D>(permission: Permission, data: UncheckedData<D>, 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, {
+    <P extends Permission>(permission: P, data: RowData<P>, 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`.
+   * `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;
+    <P extends Permission<string, unknown, "instance">>(permission: P, data: RowData<P>, 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;
+    <D>(permission: Permission, data: UncheckedData<D>, options?: Omit<DecideOptions, "explain">): ExplainedDecision;
+    <P extends Permission>(permission: P, data: RowData<P>, 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 filter: <T>(permission: Permission<string, NoInfer<T>, "instance">, rows: readonly T[], options?: DecideOptions) => T[];
+  readonly pick: <T>(permission: Permission<string, NoInfer<T>, "instance">, row: T, options?: DecideOptions) => Partial<T>;
   readonly where: (permission: Permission) => WhereResult;
   readonly actions: (resource: Permission | {
     readonly [key: string]: unknown;
@@ -425,12 +522,15 @@ type PermDock<V extends PolicyVocabulary = PolicyVocabulary> = {
     readonly scope?: string;
     readonly id?: string;
   }) => readonly Role[];
-  /** The distinct `meta.audience` values of the roles held in the active tenant, in rank order. */
+  /**
+   * 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.
+   * 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;
@@ -447,8 +547,8 @@ type PermDock<V extends PolicyVocabulary = PolicyVocabulary> = {
     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
+   * 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?: {
@@ -467,10 +567,10 @@ type PermDock<V extends PolicyVocabulary = PolicyVocabulary> = {
    */
   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`.
+   * 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;
@@ -480,37 +580,58 @@ type PermDock<V extends PolicyVocabulary = PolicyVocabulary> = {
   /**
    * 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.
+   * 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. */
+/**
+ * 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. */
+  /**
+   * 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`. */
+  /**
+   * 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. */
+  /**
+   * 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`. */
+  /**
+   * 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. */
+  /**
+   * 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. */
+  /**
+   * 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
@@ -521,11 +642,14 @@ type PermDockOptions = {
 /**
  * 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.
+ * `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. */
+/**
+ * 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 { ApprovalPolicy as C, approvalPolicies as D, ApprovalPolicyValidation as E, memoryApprovalPolicySource as O, ApprovalPolicies as S, ApprovalPolicySource as T, PermittedIdsOptions as _, PermDock as a, memoryLimitStore as b, SimulateOptions as c, getPermDock as d, getPermDockSync as f, memoryPrincipalSource as g, PrincipalSource as h, LoadedRows as i, validateApprovalPolicy as k, SnapshotOptions as l, PrincipalIdentityLink as m, DecideOptions as n, PermDockOptions as o, PrincipalIdentity as p, DeriveOptions as r, RowPair as s, DecideIdsOptions as t, WhereResult as u, Limits as v, ApprovalPolicyProblem as w, PermissionCheck as x, limits as y };
+export { memoryApprovalPolicySource as A, PermissionCheck as C, ApprovalPolicySource as D, ApprovalPolicyProblem as E, ApprovalPolicyValidation as O, memoryLimitStore as S, ApprovalPolicy as T, PrincipalSource as _, PermDock as a, Limits as b, RowPair as c, UncheckedData as d, WhereResult as f, PrincipalIdentityLink as g, PrincipalIdentity as h, LoadedRows as i, validateApprovalPolicy as j, approvalPolicies as k, SimulateOptions as l, getPermDockSync as m, DecideOptions as n, PermDockOptions as o, getPermDock as p, DeriveOptions as r, RowData as s, DecideIdsOptions as t, SnapshotOptions as u, memoryPrincipalSource as v, ApprovalPolicies as w, limits as x, PermittedIdsOptions as y };