@nmnmcc/ability 2.0.6 → 2.1.1

package/README.md

@@ -213,11 +213,12 @@ A condition reads only the data fields of a value: an own field that a loop over
 the keys sees. A rule that names a getter of a class is a `PolicyError`. Use a
 predicate for a value that comes from code. A condition may not read a field, of
 a resource or of the principal, below a value that may not be plain data: a
-class in a union that does not have the field, a list, a date, or a value of
-`Schema.Unknown`. Such a rule is a `PolicyError` too. A struct without the field
-is fine: a decode or a `make` copies it into a plain object, so the field reads
-`null`. A test reads only the fields that the simple form of its condition
-needs, as the residual does: in `x AND False`, it does not read `x`.
+union with a struct or a class that does not have the field, a list, a date, or
+a value of `Schema.Unknown`. A decision may get a value made by hand, and such a
+value may have the field with any value, as a list. Such a rule is a
+`PolicyError` too. A string in a union is fine: the field reads `null` for it. A
+test reads only the fields that the simple form of its condition needs, as the
+residual does: in `x AND False`, it does not read `x`.
 
 ## Conditions
 
@@ -234,6 +235,11 @@ The builder in `when` has these functions:
 | `principal(field)`       | Not a test. It gives a field of the principal.    |
 | `predicate(name, test)`  | The test function says yes. It may be an Effect.  |
 
+The types check each field path that you write, part by part, up to about 1000
+parts, as `link.next.next.value` of a list of links. A path that is not a field
+is a type error, and the error names the paths that may come next. The same
+check is in the fields of a rule and in the field of a request.
+
 A missing field of a resource has the value `null`. A field of the principal
 that is `null` or missing is different: a test with it is always false, also
 with `ne`. So a guest with no `userId` never matches a document with no owner.
@@ -249,9 +255,11 @@ So a predicate for a Document can not go into a rule for a Comment. Make
 conditions with the builder: a node made by hand, or a spread of a node, is not
 a condition, in the types or when the code runs.
 
-A condition may have at most 100000 nodes and 500 levels, with a shared part
-counted for each place. The builder throws an error for a larger condition. So
-no condition can make a check slow or fill the stack.
+A condition of a domain may have at most `conditionNodes` nodes, 1000000 by
+default, with each value of an `In` test, and a shared part counted for each
+place. A larger condition is a `PolicyError`, so no condition can make a check
+slow. A condition may have any number of levels: no walk fills the stack. See
+[Limits](#limits).
 
 ## Policies
 
@@ -282,12 +290,13 @@ Put policies together:
 | `Policy.firstOf([a, b])`      | The first policy that allows or denies.                          |
 | `Policy.ceiling(policy, cap)` | A deny from `cap` always wins. An allow from `cap` does nothing. |
 
-A policy tree may have at most 256 levels and 100000 nodes, with its rules and
-the nodes of their conditions, and a shared part counted for each place. A
-combinator throws an error for a larger tree, and the policy Schema does not
-decode one. The decoder reads at most 1000000 objects and array items, so no
-input can fill the stack or take a very long time. A field path may have at most
-5 parts.
+A policy tree of a domain may have at most `policyNodes` nodes, 1000000 by
+default, with its rules and the nodes and values of their conditions, and a
+shared part counted for each place. A combinator throws an error for a larger
+tree, and the policy Schema does not decode one. The decoder reads at most
+`jsonNodes` objects and array items, so no input can take a very long time. A
+field path may have at most `fieldPathParts` parts, 1000 by default. A tree may
+have any number of levels. See [Limits](#limits).
 
 A shared part of a tree is decided again for each place, so its predicates run
 each time, and `Policy.explain` lists its rules each time.
@@ -613,24 +622,39 @@ status codes: 403, 503, and 409.
 
 ## Limits
 
-Each limit keeps a walk, a decoder or a search small, so no input can fill the
-stack or take a very long time. An input past a limit is an error, as in "A
-condition has 100001 nodes. The most is 100000.". In an `Authorizer`, such an
-error is never a "yes". The `Limits` module gives each value.
-
-| Limit            | Value   | What it limits                                                                                         |
-| ---------------- | ------- | ------------------------------------------------------------------------------------------------------ |
-| `fieldPathParts` | 5       | The parts of a field path, as in `settings.model`.                                                     |
-| `patternParts`   | 16      | The parts of a field pattern.                                                                          |
-| `conditionNodes` | 100000  | The nodes of a condition, a shared part for each place.                                                |
-| `conditionDepth` | 500     | The levels of a condition.                                                                             |
-| `residualNodes`  | 10000   | The nodes of a residual condition.                                                                     |
-| `policyDepth`    | 256     | The levels of a policy tree.                                                                           |
-| `policyNodes`    | 100000  | The nodes of a policy tree, with its rules.                                                            |
-| `jsonNodes`      | 1000000 | The objects and items that a decoder reads.                                                            |
-| `catalogFields`  | 10000   | The fields of the Schema of a resource.                                                                |
-| `searchSteps`    | 1000000 | The steps of one search, as in `Policy.coverage`, and of the checks of the field patterns of a policy. |
-| `searchFields`   | 256     | The fields that one search may test.                                                                   |
+Each limit keeps a decoder, a walk or a search small, so no input can take a
+very long time or very much memory. An input past a limit is an error, as in "A
+condition has 1000001 nodes and values. The most is 1000000.". In an
+`Authorizer`, such an error is never a "yes". The `Limits` module gives each
+default, and `Limits.ceilings` gives the most that a domain may set.
+
+A walk does not fill the stack at any depth: it runs on the stack for an input
+with few levels, and in the run loop of an Effect for a deeper one. The levels
+of an input are at most its nodes, so there is no limit of levels. Note that
+`JSON.stringify` of the JSON form of a very deep policy, with many thousands of
+levels, may fail: the engine writes JSON text with a walk of its own.
+
+A domain may set its own limits:
+
+```ts
+const Deep = Domain.make({
+	principal: User,
+	resources: [Post],
+	limits: { fieldPathParts: 2000, searchSteps: 5_000_000 },
+})
+```
+
+| Limit            | Default  | Ceiling    | What it limits                                                                                         |
+| ---------------- | -------- | ---------- | ------------------------------------------------------------------------------------------------------ |
+| `fieldPathParts` | 1000     | 10000      | The parts of a field path, as in `settings.model`.                                                     |
+| `patternParts`   | 1000     | 10000      | The parts of a field pattern.                                                                          |
+| `conditionNodes` | 1000000  | 100000000  | The nodes of a condition, with each value of an `In` test, and a shared part for each place.           |
+| `residualNodes`  | 100000   | 100000000  | The nodes of a residual condition.                                                                     |
+| `policyNodes`    | 1000000  | 100000000  | The nodes of a policy tree, with its rules and the nodes and values of their conditions.               |
+| `jsonNodes`      | 10000000 | 1000000000 | The objects and items that a decoder reads.                                                            |
+| `catalogFields`  | 100000   | 10000000   | The fields in the list of the fields of the Schema of a resource or of the principal.                  |
+| `searchSteps`    | 1000000  | 1000000000 | The steps of one search, as in `Policy.coverage`, and of the checks of the field patterns of a policy. |
+| `searchFields`   | 1000     | 100000     | The fields that one search may test.                                                                   |
 
 ## Examples
 

package/dist/Authorizer.d.ts

@@ -1,6 +1,6 @@
 import { Condition, Opaque } from "./Condition.js";
 import { Any, CommonAction, Kind, Principal } from "./Domain.js";
-import { Coverage, FieldlessTarget, KindRequest, KindTarget, Policy, Request, ResidualReads, Target as Target$1 } from "./Policy.js";
+import { CheckField, Coverage, DeepKindTarget, DeepTarget as DeepTarget$1, FieldlessTarget, KindRequest, KindTarget, Policy, Request, ResidualReads, Target as Target$1 } from "./Policy.js";
 import { Decision } from "./Decision.js";
 import { Forbidden as Forbidden$1, Pending as Pending$1, PolicyUnavailable as PolicyUnavailable$1 } from "./internal/authorizer.js";
 import * as Context from "effect/Context";
@@ -8,7 +8,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Duration from "effect/Duration";
 declare namespace Authorizer_d_exports {
-  export { AnyServiceClass, Authorizer, DeciderRequest, Forbidden, GuardOptions, Options, Pending, PolicyUnavailable, Service, ServiceClass, Target, layer };
+  export { AnyServiceClass, Authorizer, DeciderRequest, DeepTarget, Forbidden, GuardOptions, Options, Pending, PolicyUnavailable, Service, ServiceClass, Target, layer };
 }
 /**
  * The error when a policy says no.
@@ -65,6 +65,15 @@ export type Pending = Pending$1;
  * @since 0.3.0
  */
 export type Target<D> = Target$1<D> | KindTarget<D>;
+/**
+ * A {@link Target} with a field of any length, which a check checks with
+ * `Policy.CheckField`.
+ *
+ * @stability stable
+ * @category models
+ * @since 2.1.0
+ */
+export type DeepTarget<D> = DeepTarget$1<D> | DeepKindTarget<D>;
 /**
  * A request to the decider.
  *
@@ -114,29 +123,29 @@ export interface Authorizer<D extends Any, E, R> {
    */
   readonly policy: Effect.Effect<Policy<D, Opaque<E>>, PolicyUnavailable | E, R>;
   /** Gives the decision of the policy. It does not ask the decider. */
-  readonly decide: (target: Target$1<D>) => Effect.Effect<Decision, PolicyUnavailable | E, R>;
+  readonly decide: <const T extends DeepTarget$1<D>>(target: T & CheckField<D, T>) => Effect.Effect<Decision, PolicyUnavailable | E, R>;
   /** Succeeds when the principal may do the act, and fails when it may not. */
-  readonly check: (target: Target<D>) => Effect.Effect<void, Forbidden | Pending | PolicyUnavailable | E, R>;
+  readonly check: <const T extends DeepTarget<D>>(target: T & CheckField<D, T>) => Effect.Effect<void, Forbidden | Pending | PolicyUnavailable | E, R>;
   /**
    * Checks the read action first, and fails with the error of `hide` when the
    * principal may not see the resource. Then it checks the act. Use it to
    * answer "not found" to a principal that may not know that a resource
    * exists.
    */
-  readonly guard: <const T extends Target$1<D>, E2>(target: T, options: GuardOptions<D, E2, T["resource"]["_tag"]>) => Effect.Effect<void, E2 | Forbidden | Pending | PolicyUnavailable | E, R>;
+  readonly guard: <const T extends DeepTarget$1<D>, E2>(target: T & CheckField<D, T>, options: GuardOptions<D, E2, T["resource"]["_tag"]>) => Effect.Effect<void, E2 | Forbidden | Pending | PolicyUnavailable | E, R>;
   /**
    * Gives the condition on resource values that the principal may act on,
    * inside the scope of the target when it has one. Change it into a query
    * with `Condition.fold`. It is `False` when the principal may act on no
    * value, so the list is empty: it is not an error.
    */
-  readonly filter: <const T extends KindTarget<D>>(target: T) => Effect.Effect<Condition<ResidualReads<D, T["kind"]>, Opaque<E>>, PolicyUnavailable | E, R>;
+  readonly filter: <const T extends DeepKindTarget<D>>(target: T & CheckField<D, T>) => Effect.Effect<Condition<ResidualReads<D, T["kind"]>, Opaque<E>>, PolicyUnavailable | E, R>;
   /**
    * Tells if the principal may act on all, none or some of the values in
    * the scope of the target. See `Policy.coverage`. Use it to show a button
    * only when the answer is not `None`.
    */
-  readonly coverage: <const T extends KindTarget<D>>(target: T) => Effect.Effect<Coverage<ResidualReads<D, T["kind"]>, Opaque<E>>, PolicyUnavailable | E, R>;
+  readonly coverage: <const T extends DeepKindTarget<D>>(target: T & CheckField<D, T>) => Effect.Effect<Coverage<ResidualReads<D, T["kind"]>, Opaque<E>>, PolicyUnavailable | E, R>;
   /** Gives the fields of a value that the principal may use. */
   readonly permittedFields: (target: FieldlessTarget<D>) => Effect.Effect<ReadonlyArray<string>, PolicyUnavailable | E, R>;
   /**
@@ -157,11 +166,11 @@ export interface ServiceClass<Self, Id extends string, D extends Any, E, R> exte
   readonly domain: D;
   /** The Effect that gives the principal of the current request. */
   readonly principal: Effect.Effect<Principal<D>, E, R>;
-  readonly decide: (target: Target$1<D>) => Effect.Effect<Decision, PolicyUnavailable | E, R | Self>;
-  readonly check: (target: Target<D>) => Effect.Effect<void, Forbidden | Pending | PolicyUnavailable | E, R | Self>;
-  readonly guard: <const T extends Target$1<D>, E2>(target: T, options: GuardOptions<D, E2, T["resource"]["_tag"]>) => Effect.Effect<void, E2 | Forbidden | Pending | PolicyUnavailable | E, R | Self>;
-  readonly filter: <const T extends KindTarget<D>>(target: T) => Effect.Effect<Condition<ResidualReads<D, T["kind"]>, Opaque<E>>, PolicyUnavailable | E, R | Self>;
-  readonly coverage: <const T extends KindTarget<D>>(target: T) => Effect.Effect<Coverage<ResidualReads<D, T["kind"]>, Opaque<E>>, PolicyUnavailable | E, R | Self>;
+  readonly decide: <const T extends DeepTarget$1<D>>(target: T & CheckField<D, T>) => Effect.Effect<Decision, PolicyUnavailable | E, R | Self>;
+  readonly check: <const T extends DeepTarget<D>>(target: T & CheckField<D, T>) => Effect.Effect<void, Forbidden | Pending | PolicyUnavailable | E, R | Self>;
+  readonly guard: <const T extends DeepTarget$1<D>, E2>(target: T & CheckField<D, T>, options: GuardOptions<D, E2, T["resource"]["_tag"]>) => Effect.Effect<void, E2 | Forbidden | Pending | PolicyUnavailable | E, R | Self>;
+  readonly filter: <const T extends DeepKindTarget<D>>(target: T & CheckField<D, T>) => Effect.Effect<Condition<ResidualReads<D, T["kind"]>, Opaque<E>>, PolicyUnavailable | E, R | Self>;
+  readonly coverage: <const T extends DeepKindTarget<D>>(target: T & CheckField<D, T>) => Effect.Effect<Coverage<ResidualReads<D, T["kind"]>, Opaque<E>>, PolicyUnavailable | E, R | Self>;
   readonly permittedFields: (target: FieldlessTarget<D>) => Effect.Effect<ReadonlyArray<string>, PolicyUnavailable | E, R | Self>;
 }
 /**

package/dist/Authorizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Authorizer.d.ts","names":["Internal.Forbidden","Internal.PolicyUnavailable","Internal.Pending","Policy.Target","Policy.KindTarget","Policy.Request","Policy.KindRequest","Domain.Kind","Domain.CommonAction","Domain.Any","Domain.Principal","Condition.Opaque","Policy.Policy","Decision.Decision","Policy.ResidualReads","Condition.Condition","Policy.Coverage","Policy.FieldlessTarget"],"sources":["../src/Authorizer.ts"],"mappings":"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"}
+{"version":3,"file":"Authorizer.d.ts","names":["Internal.Forbidden","Internal.PolicyUnavailable","Internal.Pending","Policy.Target","Policy.KindTarget","Policy.DeepTarget","Policy.DeepKindTarget","Policy.Request","Policy.KindRequest","Domain.Kind","Domain.CommonAction","Domain.Any","Domain.Principal","Condition.Opaque","Policy.Policy","Policy.CheckField","Decision.Decision","Policy.ResidualReads","Condition.Condition","Policy.Coverage","Policy.FieldlessTarget"],"sources":["../src/Authorizer.ts"],"mappings":"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"}

package/dist/Authorizer.js.map

@@ -1 +1 @@
-{"version":3,"file":"Authorizer.js","names":["Internal.Forbidden","Internal.PolicyUnavailable","Internal.Pending","Internal.Service","Internal.makeLayer"],"sources":["../src/Authorizer.ts"],"sourcesContent":["/**\n * An authorizer is an Effect service that makes decisions for the principal\n * of the current request.\n *\n * You make the service class, in the same way as `Context.Service`. Give the\n * domain, and the Effect that gives the principal of the current request. The\n * error type and the service type of the checks come from that Effect:\n *\n * ```ts\n * class Auth extends Authorizer.Service<Auth>()(\"app/Auth\", {\n *   domain: App,\n *   principal: Identity,\n * }) {}\n * ```\n *\n * Then give a layer with {@link layer}. It says how to load the policy of a\n * principal. The policy of each principal is loaded once and kept in a cache\n * for a short time.\n *\n * Then use the service in a handler:\n *\n * ```ts\n * yield* Auth.check({ action: \"update\", resource: document })\n * ```\n *\n * A \"no\" answer goes into the error channel as {@link Forbidden}. When the\n * policy can not be loaded, the check fails with {@link PolicyUnavailable}.\n * So the check fails closed: an error is never a \"yes\".\n *\n * When no rule gives an answer, the authorizer asks the decider, if there is\n * one. A decider may answer at once, or fail with {@link Pending} when a person\n * or another service must answer later.\n *\n * @stability stable\n * @since 0.3.0\n */\nimport type * as Context from \"effect/Context\"\nimport type * as Duration from \"effect/Duration\"\nimport type * as Effect from \"effect/Effect\"\nimport type * as Layer from \"effect/Layer\"\nimport type * as Condition from \"./Condition.ts\"\nimport type * as Decision from \"./Decision.ts\"\nimport type * as Domain from \"./Domain.ts\"\nimport * as Internal from \"./internal/authorizer.ts\"\nimport type * as Policy from \"./Policy.ts\"\n\n/**\n * The error when a policy says no.\n *\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport const Forbidden: typeof Internal.Forbidden = Internal.Forbidden\n\n/**\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport type Forbidden = Internal.Forbidden\n\n/**\n * The error when the policy of the principal can not be loaded. The cause is\n * kept, but it is not shown to the client.\n *\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport const PolicyUnavailable: typeof Internal.PolicyUnavailable =\n\tInternal.PolicyUnavailable\n\n/**\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport type PolicyUnavailable = Internal.PolicyUnavailable\n\n/**\n * The error when a decider must wait for an answer. `ticket` names the\n * request that waits, so the client can come back for the answer.\n *\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport const Pending: typeof Internal.Pending = Internal.Pending\n\n/**\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport type Pending = Internal.Pending\n\n/**\n * What a check is about: an act on a resource value, or an act on a kind of\n * resource. A check on a kind passes only when the policy allows the act on\n * every value of the kind. With a scope (`within`), it passes when the policy\n * allows the act on every value in the scope, and the scope is not empty.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Target<D> = Policy.Target<D> | Policy.KindTarget<D>\n\n/**\n * A request to the decider.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type DeciderRequest<D> = Policy.Request<D> | Policy.KindRequest<D>\n\n/**\n * The options of a guard.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type GuardOptions<D, E2, K extends string = Domain.Kind<D>> = {\n\t/** The error when the principal may not see the resource. */\n\treadonly hide: () => E2\n} & (\"read\" extends Domain.CommonAction<D, K>\n\t? {\n\t\t\t/**\n\t\t\t * The action that lets the principal see the resource. It must be an\n\t\t\t * action of every kind in `K`. The default is `\"read\"`.\n\t\t\t */\n\t\t\treadonly read?: Domain.CommonAction<D, K>\n\t\t}\n\t: {\n\t\t\t/**\n\t\t\t * The action that lets the principal see the resource. It must be an\n\t\t\t * action of every kind in `K`. Some kind in `K` has no `\"read\"`\n\t\t\t * action, so you must give it.\n\t\t\t */\n\t\t\treadonly read: Domain.CommonAction<D, K>\n\t\t})\n\n/**\n * The service.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Authorizer<D extends Domain.Any, E, R> {\n\treadonly domain: D\n\t/** The principal of the current request. */\n\treadonly principal: Effect.Effect<Domain.Principal<D>, E, R>\n\t/**\n\t * The policy of the principal of the current request. Its predicates have\n\t * the services of the layer. It may have predicates, so it is opaque.\n\t */\n\treadonly policy: Effect.Effect<\n\t\tPolicy.Policy<D, Condition.Opaque<E>>,\n\t\tPolicyUnavailable | E,\n\t\tR\n\t>\n\t/** Gives the decision of the policy. It does not ask the decider. */\n\treadonly decide: (\n\t\ttarget: Policy.Target<D>,\n\t) => Effect.Effect<Decision.Decision, PolicyUnavailable | E, R>\n\t/** Succeeds when the principal may do the act, and fails when it may not. */\n\treadonly check: (\n\t\ttarget: Target<D>,\n\t) => Effect.Effect<void, Forbidden | Pending | PolicyUnavailable | E, R>\n\t/**\n\t * Checks the read action first, and fails with the error of `hide` when the\n\t * principal may not see the resource. Then it checks the act. Use it to\n\t * answer \"not found\" to a principal that may not know that a resource\n\t * exists.\n\t */\n\treadonly guard: <const T extends Policy.Target<D>, E2>(\n\t\ttarget: T,\n\t\toptions: GuardOptions<D, E2, T[\"resource\"][\"_tag\"]>,\n\t) => Effect.Effect<void, E2 | Forbidden | Pending | PolicyUnavailable | E, R>\n\t/**\n\t * Gives the condition on resource values that the principal may act on,\n\t * inside the scope of the target when it has one. Change it into a query\n\t * with `Condition.fold`. It is `False` when the principal may act on no\n\t * value, so the list is empty: it is not an error.\n\t */\n\treadonly filter: <const T extends Policy.KindTarget<D>>(\n\t\ttarget: T,\n\t) => Effect.Effect<\n\t\tCondition.Condition<\n\t\t\tPolicy.ResidualReads<D, T[\"kind\"]>,\n\t\t\tCondition.Opaque<E>\n\t\t>,\n\t\tPolicyUnavailable | E,\n\t\tR\n\t>\n\t/**\n\t * Tells if the principal may act on all, none or some of the values in\n\t * the scope of the target. See `Policy.coverage`. Use it to show a button\n\t * only when the answer is not `None`.\n\t */\n\treadonly coverage: <const T extends Policy.KindTarget<D>>(\n\t\ttarget: T,\n\t) => Effect.Effect<\n\t\tPolicy.Coverage<Policy.ResidualReads<D, T[\"kind\"]>, Condition.Opaque<E>>,\n\t\tPolicyUnavailable | E,\n\t\tR\n\t>\n\t/** Gives the fields of a value that the principal may use. */\n\treadonly permittedFields: (\n\t\ttarget: Policy.FieldlessTarget<D>,\n\t) => Effect.Effect<ReadonlyArray<string>, PolicyUnavailable | E, R>\n\t/**\n\t * Removes the cached policy of a principal, or of every principal. Call it\n\t * after a change to the rules or roles of a principal.\n\t */\n\treadonly invalidate: (principal?: Domain.Principal<D>) => Effect.Effect<void>\n}\n\n/**\n * The class made by {@link Service}. The static functions use the service\n * from the context.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface ServiceClass<\n\tSelf,\n\tId extends string,\n\tD extends Domain.Any,\n\tE,\n\tR,\n> extends Context.ServiceClass<Self, Id, Authorizer<D, E, R>> {\n\treadonly domain: D\n\t/** The Effect that gives the principal of the current request. */\n\treadonly principal: Effect.Effect<Domain.Principal<D>, E, R>\n\treadonly decide: (\n\t\ttarget: Policy.Target<D>,\n\t) => Effect.Effect<Decision.Decision, PolicyUnavailable | E, R | Self>\n\treadonly check: (\n\t\ttarget: Target<D>,\n\t) => Effect.Effect<\n\t\tvoid,\n\t\tForbidden | Pending | PolicyUnavailable | E,\n\t\tR | Self\n\t>\n\treadonly guard: <const T extends Policy.Target<D>, E2>(\n\t\ttarget: T,\n\t\toptions: GuardOptions<D, E2, T[\"resource\"][\"_tag\"]>,\n\t) => Effect.Effect<\n\t\tvoid,\n\t\tE2 | Forbidden | Pending | PolicyUnavailable | E,\n\t\tR | Self\n\t>\n\treadonly filter: <const T extends Policy.KindTarget<D>>(\n\t\ttarget: T,\n\t) => Effect.Effect<\n\t\tCondition.Condition<\n\t\t\tPolicy.ResidualReads<D, T[\"kind\"]>,\n\t\t\tCondition.Opaque<E>\n\t\t>,\n\t\tPolicyUnavailable | E,\n\t\tR | Self\n\t>\n\treadonly coverage: <const T extends Policy.KindTarget<D>>(\n\t\ttarget: T,\n\t) => Effect.Effect<\n\t\tPolicy.Coverage<Policy.ResidualReads<D, T[\"kind\"]>, Condition.Opaque<E>>,\n\t\tPolicyUnavailable | E,\n\t\tR | Self\n\t>\n\treadonly permittedFields: (\n\t\ttarget: Policy.FieldlessTarget<D>,\n\t) => Effect.Effect<ReadonlyArray<string>, PolicyUnavailable | E, R | Self>\n}\n\n/**\n * Any service class made by {@link Service}.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type AnyServiceClass = Context.Key<any, any> & {\n\treadonly domain: Domain.Any\n\treadonly principal: Effect.Effect<any, any, any>\n}\n\n/**\n * Makes an authorizer service class for a domain.\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const Service: <Self>() => <\n\tconst Id extends string,\n\tD extends Domain.Any,\n\tE = never,\n\tR = never,\n>(\n\tid: Id,\n\toptions: {\n\t\treadonly domain: D\n\t\t/** Gives the principal of the current request. */\n\t\treadonly principal: Effect.Effect<Domain.Principal<NoInfer<D>>, E, R>\n\t},\n) => ServiceClass<Self, Id, D, E, R> = Internal.Service as never\n\n/**\n * The options of {@link layer}.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Options<D extends Domain.Any, E, R, EL, RL, RP> {\n\t/**\n\t * Loads the policy of a principal. A failure becomes\n\t * {@link PolicyUnavailable}. The services of the predicates of the policy\n\t * are taken when the layer is built.\n\t */\n\treadonly policy: (\n\t\tprincipal: Domain.Principal<D>,\n\t) => Effect.Effect<Policy.Policy<D, Condition.Opaque<E, RP>>, EL, RL>\n\t/**\n\t * Answers when no rule gives an answer. Without a decider, such a request\n\t * fails with {@link Forbidden}.\n\t */\n\treadonly decider?: (\n\t\trequest: DeciderRequest<D>,\n\t) => Effect.Effect<Decision.Decision, Pending | E, R>\n\t/**\n\t * How the policies are kept. The default keeps 1000 policies for 30 seconds.\n\t * Give `false` to load the policy for each check.\n\t *\n\t * The key of a principal is the text of its JSON form, from the Schema of\n\t * the principal of the domain. A principal is kept only when the value that\n\t * the Schema decodes from that form is `Equal` to it. The loader always\n\t * gets that decoded copy, also with no cache, so two principals with one\n\t * key get one policy, and the cache can not change an answer. So the loader\n\t * must decide by the data of the principal, not by the identity of its\n\t * objects. A principal with no JSON form is not kept, and the loader gets\n\t * it as it is. Give `key` to make the key in another way.\n\t */\n\treadonly cache?:\n\t\t| {\n\t\t\t\treadonly capacity?: number\n\t\t\t\treadonly timeToLive?: Duration.Input\n\t\t\t\treadonly key?: (principal: Domain.Principal<D>) => string | undefined\n\t\t  }\n\t\t| false\n}\n\n/**\n * Makes the layer of an authorizer.\n *\n * @stability stable\n * @category layers\n * @since 0.3.0\n */\nexport const layer: <\n\tSelf,\n\tId extends string,\n\tD extends Domain.Any,\n\tE,\n\tR,\n\tEL = never,\n\tRL = never,\n\tRP = never,\n>(\n\tservice: ServiceClass<Self, Id, D, E, R>,\n\toptions: Options<D, NoInfer<E>, NoInfer<R>, EL, RL, RP>,\n) => Layer.Layer<Self, never, RL | RP> = Internal.makeLayer as never\n"],"mappings":";;;;;;;;;;;;;;;;;AAqDA,MAAa,YAAuCA;;;;;;;;;AAiBpD,MAAa,oBACZC;;;;;;;;;AAiBD,MAAa,UAAmCC;;;;;;;;AAmNhD,MAAa,UAY0BC;;;;;;;;AAsDvC,MAAa,QAY4BC"}
+{"version":3,"file":"Authorizer.js","names":["Internal.Forbidden","Internal.PolicyUnavailable","Internal.Pending","Internal.Service","Internal.makeLayer"],"sources":["../src/Authorizer.ts"],"sourcesContent":["/**\n * An authorizer is an Effect service that makes decisions for the principal\n * of the current request.\n *\n * You make the service class, in the same way as `Context.Service`. Give the\n * domain, and the Effect that gives the principal of the current request. The\n * error type and the service type of the checks come from that Effect:\n *\n * ```ts\n * class Auth extends Authorizer.Service<Auth>()(\"app/Auth\", {\n *   domain: App,\n *   principal: Identity,\n * }) {}\n * ```\n *\n * Then give a layer with {@link layer}. It says how to load the policy of a\n * principal. The policy of each principal is loaded once and kept in a cache\n * for a short time.\n *\n * Then use the service in a handler:\n *\n * ```ts\n * yield* Auth.check({ action: \"update\", resource: document })\n * ```\n *\n * A \"no\" answer goes into the error channel as {@link Forbidden}. When the\n * policy can not be loaded, the check fails with {@link PolicyUnavailable}.\n * So the check fails closed: an error is never a \"yes\".\n *\n * When no rule gives an answer, the authorizer asks the decider, if there is\n * one. A decider may answer at once, or fail with {@link Pending} when a person\n * or another service must answer later.\n *\n * @stability stable\n * @since 0.3.0\n */\nimport type * as Context from \"effect/Context\"\nimport type * as Duration from \"effect/Duration\"\nimport type * as Effect from \"effect/Effect\"\nimport type * as Layer from \"effect/Layer\"\nimport type * as Condition from \"./Condition.ts\"\nimport type * as Decision from \"./Decision.ts\"\nimport type * as Domain from \"./Domain.ts\"\nimport * as Internal from \"./internal/authorizer.ts\"\nimport type * as Policy from \"./Policy.ts\"\n\n/**\n * The error when a policy says no.\n *\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport const Forbidden: typeof Internal.Forbidden = Internal.Forbidden\n\n/**\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport type Forbidden = Internal.Forbidden\n\n/**\n * The error when the policy of the principal can not be loaded. The cause is\n * kept, but it is not shown to the client.\n *\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport const PolicyUnavailable: typeof Internal.PolicyUnavailable =\n\tInternal.PolicyUnavailable\n\n/**\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport type PolicyUnavailable = Internal.PolicyUnavailable\n\n/**\n * The error when a decider must wait for an answer. `ticket` names the\n * request that waits, so the client can come back for the answer.\n *\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport const Pending: typeof Internal.Pending = Internal.Pending\n\n/**\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport type Pending = Internal.Pending\n\n/**\n * What a check is about: an act on a resource value, or an act on a kind of\n * resource. A check on a kind passes only when the policy allows the act on\n * every value of the kind. With a scope (`within`), it passes when the policy\n * allows the act on every value in the scope, and the scope is not empty.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Target<D> = Policy.Target<D> | Policy.KindTarget<D>\n\n/**\n * A {@link Target} with a field of any length, which a check checks with\n * `Policy.CheckField`.\n *\n * @stability stable\n * @category models\n * @since 2.1.0\n */\nexport type DeepTarget<D> = Policy.DeepTarget<D> | Policy.DeepKindTarget<D>\n\n/**\n * A request to the decider.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type DeciderRequest<D> = Policy.Request<D> | Policy.KindRequest<D>\n\n/**\n * The options of a guard.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type GuardOptions<D, E2, K extends string = Domain.Kind<D>> = {\n\t/** The error when the principal may not see the resource. */\n\treadonly hide: () => E2\n} & (\"read\" extends Domain.CommonAction<D, K>\n\t? {\n\t\t\t/**\n\t\t\t * The action that lets the principal see the resource. It must be an\n\t\t\t * action of every kind in `K`. The default is `\"read\"`.\n\t\t\t */\n\t\t\treadonly read?: Domain.CommonAction<D, K>\n\t\t}\n\t: {\n\t\t\t/**\n\t\t\t * The action that lets the principal see the resource. It must be an\n\t\t\t * action of every kind in `K`. Some kind in `K` has no `\"read\"`\n\t\t\t * action, so you must give it.\n\t\t\t */\n\t\t\treadonly read: Domain.CommonAction<D, K>\n\t\t})\n\n/**\n * The service.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Authorizer<D extends Domain.Any, E, R> {\n\treadonly domain: D\n\t/** The principal of the current request. */\n\treadonly principal: Effect.Effect<Domain.Principal<D>, E, R>\n\t/**\n\t * The policy of the principal of the current request. Its predicates have\n\t * the services of the layer. It may have predicates, so it is opaque.\n\t */\n\treadonly policy: Effect.Effect<\n\t\tPolicy.Policy<D, Condition.Opaque<E>>,\n\t\tPolicyUnavailable | E,\n\t\tR\n\t>\n\t/** Gives the decision of the policy. It does not ask the decider. */\n\treadonly decide: <const T extends Policy.DeepTarget<D>>(\n\t\ttarget: T & Policy.CheckField<D, T>,\n\t) => Effect.Effect<Decision.Decision, PolicyUnavailable | E, R>\n\t/** Succeeds when the principal may do the act, and fails when it may not. */\n\treadonly check: <const T extends DeepTarget<D>>(\n\t\ttarget: T & Policy.CheckField<D, T>,\n\t) => Effect.Effect<void, Forbidden | Pending | PolicyUnavailable | E, R>\n\t/**\n\t * Checks the read action first, and fails with the error of `hide` when the\n\t * principal may not see the resource. Then it checks the act. Use it to\n\t * answer \"not found\" to a principal that may not know that a resource\n\t * exists.\n\t */\n\treadonly guard: <const T extends Policy.DeepTarget<D>, E2>(\n\t\ttarget: T & Policy.CheckField<D, T>,\n\t\toptions: GuardOptions<D, E2, T[\"resource\"][\"_tag\"]>,\n\t) => Effect.Effect<void, E2 | Forbidden | Pending | PolicyUnavailable | E, R>\n\t/**\n\t * Gives the condition on resource values that the principal may act on,\n\t * inside the scope of the target when it has one. Change it into a query\n\t * with `Condition.fold`. It is `False` when the principal may act on no\n\t * value, so the list is empty: it is not an error.\n\t */\n\treadonly filter: <const T extends Policy.DeepKindTarget<D>>(\n\t\ttarget: T & Policy.CheckField<D, T>,\n\t) => Effect.Effect<\n\t\tCondition.Condition<\n\t\t\tPolicy.ResidualReads<D, T[\"kind\"]>,\n\t\t\tCondition.Opaque<E>\n\t\t>,\n\t\tPolicyUnavailable | E,\n\t\tR\n\t>\n\t/**\n\t * Tells if the principal may act on all, none or some of the values in\n\t * the scope of the target. See `Policy.coverage`. Use it to show a button\n\t * only when the answer is not `None`.\n\t */\n\treadonly coverage: <const T extends Policy.DeepKindTarget<D>>(\n\t\ttarget: T & Policy.CheckField<D, T>,\n\t) => Effect.Effect<\n\t\tPolicy.Coverage<Policy.ResidualReads<D, T[\"kind\"]>, Condition.Opaque<E>>,\n\t\tPolicyUnavailable | E,\n\t\tR\n\t>\n\t/** Gives the fields of a value that the principal may use. */\n\treadonly permittedFields: (\n\t\ttarget: Policy.FieldlessTarget<D>,\n\t) => Effect.Effect<ReadonlyArray<string>, PolicyUnavailable | E, R>\n\t/**\n\t * Removes the cached policy of a principal, or of every principal. Call it\n\t * after a change to the rules or roles of a principal.\n\t */\n\treadonly invalidate: (principal?: Domain.Principal<D>) => Effect.Effect<void>\n}\n\n/**\n * The class made by {@link Service}. The static functions use the service\n * from the context.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface ServiceClass<\n\tSelf,\n\tId extends string,\n\tD extends Domain.Any,\n\tE,\n\tR,\n> extends Context.ServiceClass<Self, Id, Authorizer<D, E, R>> {\n\treadonly domain: D\n\t/** The Effect that gives the principal of the current request. */\n\treadonly principal: Effect.Effect<Domain.Principal<D>, E, R>\n\treadonly decide: <const T extends Policy.DeepTarget<D>>(\n\t\ttarget: T & Policy.CheckField<D, T>,\n\t) => Effect.Effect<Decision.Decision, PolicyUnavailable | E, R | Self>\n\treadonly check: <const T extends DeepTarget<D>>(\n\t\ttarget: T & Policy.CheckField<D, T>,\n\t) => Effect.Effect<\n\t\tvoid,\n\t\tForbidden | Pending | PolicyUnavailable | E,\n\t\tR | Self\n\t>\n\treadonly guard: <const T extends Policy.DeepTarget<D>, E2>(\n\t\ttarget: T & Policy.CheckField<D, T>,\n\t\toptions: GuardOptions<D, E2, T[\"resource\"][\"_tag\"]>,\n\t) => Effect.Effect<\n\t\tvoid,\n\t\tE2 | Forbidden | Pending | PolicyUnavailable | E,\n\t\tR | Self\n\t>\n\treadonly filter: <const T extends Policy.DeepKindTarget<D>>(\n\t\ttarget: T & Policy.CheckField<D, T>,\n\t) => Effect.Effect<\n\t\tCondition.Condition<\n\t\t\tPolicy.ResidualReads<D, T[\"kind\"]>,\n\t\t\tCondition.Opaque<E>\n\t\t>,\n\t\tPolicyUnavailable | E,\n\t\tR | Self\n\t>\n\treadonly coverage: <const T extends Policy.DeepKindTarget<D>>(\n\t\ttarget: T & Policy.CheckField<D, T>,\n\t) => Effect.Effect<\n\t\tPolicy.Coverage<Policy.ResidualReads<D, T[\"kind\"]>, Condition.Opaque<E>>,\n\t\tPolicyUnavailable | E,\n\t\tR | Self\n\t>\n\treadonly permittedFields: (\n\t\ttarget: Policy.FieldlessTarget<D>,\n\t) => Effect.Effect<ReadonlyArray<string>, PolicyUnavailable | E, R | Self>\n}\n\n/**\n * Any service class made by {@link Service}.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type AnyServiceClass = Context.Key<any, any> & {\n\treadonly domain: Domain.Any\n\treadonly principal: Effect.Effect<any, any, any>\n}\n\n/**\n * Makes an authorizer service class for a domain.\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const Service: <Self>() => <\n\tconst Id extends string,\n\tD extends Domain.Any,\n\tE = never,\n\tR = never,\n>(\n\tid: Id,\n\toptions: {\n\t\treadonly domain: D\n\t\t/** Gives the principal of the current request. */\n\t\treadonly principal: Effect.Effect<Domain.Principal<NoInfer<D>>, E, R>\n\t},\n) => ServiceClass<Self, Id, D, E, R> = Internal.Service as never\n\n/**\n * The options of {@link layer}.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Options<D extends Domain.Any, E, R, EL, RL, RP> {\n\t/**\n\t * Loads the policy of a principal. A failure becomes\n\t * {@link PolicyUnavailable}. The services of the predicates of the policy\n\t * are taken when the layer is built.\n\t */\n\treadonly policy: (\n\t\tprincipal: Domain.Principal<D>,\n\t) => Effect.Effect<Policy.Policy<D, Condition.Opaque<E, RP>>, EL, RL>\n\t/**\n\t * Answers when no rule gives an answer. Without a decider, such a request\n\t * fails with {@link Forbidden}.\n\t */\n\treadonly decider?: (\n\t\trequest: DeciderRequest<D>,\n\t) => Effect.Effect<Decision.Decision, Pending | E, R>\n\t/**\n\t * How the policies are kept. The default keeps 1000 policies for 30 seconds.\n\t * Give `false` to load the policy for each check.\n\t *\n\t * The key of a principal is the text of its JSON form, from the Schema of\n\t * the principal of the domain. A principal is kept only when the value that\n\t * the Schema decodes from that form is `Equal` to it. The loader always\n\t * gets that decoded copy, also with no cache, so two principals with one\n\t * key get one policy, and the cache can not change an answer. So the loader\n\t * must decide by the data of the principal, not by the identity of its\n\t * objects. A principal with no JSON form is not kept, and the loader gets\n\t * it as it is. Give `key` to make the key in another way.\n\t */\n\treadonly cache?:\n\t\t| {\n\t\t\t\treadonly capacity?: number\n\t\t\t\treadonly timeToLive?: Duration.Input\n\t\t\t\treadonly key?: (principal: Domain.Principal<D>) => string | undefined\n\t\t  }\n\t\t| false\n}\n\n/**\n * Makes the layer of an authorizer.\n *\n * @stability stable\n * @category layers\n * @since 0.3.0\n */\nexport const layer: <\n\tSelf,\n\tId extends string,\n\tD extends Domain.Any,\n\tE,\n\tR,\n\tEL = never,\n\tRL = never,\n\tRP = never,\n>(\n\tservice: ServiceClass<Self, Id, D, E, R>,\n\toptions: Options<D, NoInfer<E>, NoInfer<R>, EL, RL, RP>,\n) => Layer.Layer<Self, never, RL | RP> = Internal.makeLayer as never\n"],"mappings":";;;;;;;;;;;;;;;;;AAqDA,MAAa,YAAuCA;;;;;;;;;AAiBpD,MAAa,oBACZC;;;;;;;;;AAiBD,MAAa,UAAmCC;;;;;;;;AA6NhD,MAAa,UAY0BC;;;;;;;;AAsDvC,MAAa,QAY4BC"}

package/dist/Condition.d.ts

@@ -9,14 +9,14 @@ import * as HashSet from "effect/HashSet";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
 import * as Duration from "effect/Duration";
 import * as BigDecimal from "effect/BigDecimal";
-import * as Cause from "effect/Cause";
 import * as DateTime from "effect/DateTime";
-import * as Exit from "effect/Exit";
 import * as Redacted from "effect/Redacted";
 declare namespace Condition_d_exports {
-  export { And, Any, Ast, Builder, Compare, CompareOperator, Condition, Encoded, EncodedOperand, ErrorOf, Example, Exists, False, FieldName, FieldPath, FieldSelector, FieldValue, In, Input, Interpreter, Literal, Not, Opaque, OpaqueOf, Operand, OperandOf, Or, PathValue, PlainCondition, Predicate, PrincipalRef, Provided, Reads, ReadsOf, Ref, Satisfiability, SatisfiableOptions, Scalar, ServicesOf, Test, True, Under, Untranslatable, always, and, andAll, builder, evaluate, evaluateSync, fields, fold, never, not, or, orAll, partial, provideContext, satisfiable, schema, simplify };
+  export { And, Any, Ast, Builder, Compare, CompareOperator, Condition, Encoded, EncodedOperand, ErrorOf, Example, Exists, False, FieldName, FieldPath, FieldSelector, FieldValue, In, Input, Interpreter, Literal, NamePath, Not, Opaque, OpaqueOf, Operand, OperandOf, Or, PathValue, PlainCondition, Predicate, PrincipalRef, Provided, ReadPath, Reads, ReadsOf, Ref, Satisfiability, SatisfiableOptions, Scalar, SelectPath, ServicesOf, Test, True, Under, Untranslatable, always, and, andAll, builder, evaluate, evaluateSync, fields, fold, never, not, or, orAll, partial, provideContext, satisfiable, schema, simplify };
 }
 /**
  * A value that a condition can compare.
@@ -276,7 +276,7 @@ type FieldPathInternal<T, Depth extends number, Arrays extends boolean, Parents
  */
 type PathsOf<K extends string, V, Depth extends number, Arrays extends boolean, Parents extends boolean> = ([V] extends [never] ? K : {} extends V ? K : never) | ([Extract<V, Leaf | Whole>] extends [never] ? never : K) | ([Extract<V, ReadonlyArray<unknown>>] extends [never] ? never : Arrays extends true ? K : never) | (Arrays extends true ? ObjectPaths<K, Exclude<V, Leaf | Whole | Function | ReadonlyArray<unknown>>, Depth, Arrays, Parents> : [Extract<V, Whole | Function | ReadonlyArray<unknown>>] extends [never] ? ObjectPaths<K, Exclude<V, Leaf>, Depth, Arrays, Parents> : never);
 /** The paths of a field `K` that holds the objects `O`, and of the fields below. */
-type ObjectPaths<K extends string, O, Depth extends number, Arrays extends boolean, Parents extends boolean> = [O] extends [never] ? never : (Parents extends true ? K : Arrays extends true ? string extends keyof O ? K : number extends keyof O ? K : [Depth] extends [0] ? K : never : never) | `${K}.${FieldPathInternal<O, PreviousDepth[Depth], Arrays, Parents>}`;
+type ObjectPaths<K extends string, O, Depth extends number, Arrays extends boolean, Parents extends boolean> = [O] extends [never] ? never : (Parents extends true ? K : Arrays extends true ? string extends keyof O ? K : number extends keyof O ? K : never : never) | `${K}.${FieldPathInternal<O, PreviousDepth[Depth], Arrays, Parents>}`;
 /**
  * The paths of the fields of `T` that hold one value, with dots for nested
  * fields. Arrays are left out. A map, a set, a date, a URL, a byte array, an
@@ -334,14 +334,116 @@ type Normalize<A> = Exclude<A, undefined> | (undefined extends A ? null : never)
  * @category utility types
  * @since 0.3.0
  */
-export type PathValue<T, Path extends string> = T extends unknown ? PathValueIn<T, Path> : never;
-/** The type of the field at `Path` of `T`, which is not a union. */
-type PathValueIn<T, Path extends string> = T extends object ? Path extends `${infer Head}.${infer Rest}` ? PathValue<ChildOf<T, Head>, Rest> : Normalize<ChildOf<T, Path>> : null;
+export type PathValue<T, Path extends string> = ValueWalk<T, Path>;
+/**
+ * The values of the part `Name` of each type of `U`. A part below a value
+ * that is not an object, as below a string or `null`, is `null`.
+ */
+type StepValue<U, Name extends string> = U extends unknown ? U extends object ? ChildOf<U, Name> : null : never;
+/**
+ * Walks a path two parts at a time, with the values of each step. The type
+ * checker takes at most about 1000 steps of a type that calls itself, so a
+ * walk of one part at a time would stop before a path of 1000 parts.
+ */
+type ValueWalk<U, Path extends string> = Path extends `${infer A}.${infer B}.${infer Rest}` ? ValueWalk<StepValue<StepValue<U, A>, B>, Rest> : Path extends `${infer A}.${infer B}` ? Normalize<StepValue<StepValue<U, A>, B>> : Normalize<StepValue<U, Path>>;
 /**
  * The type of the part `Name` of `T`. A part of a path is text, so the part
  * `"1"` names the number key `1` too, as of a record with number keys.
  */
 type ChildOf<T, Name extends string> = Name extends keyof T ? T[Name] : Name extends `${infer N extends number}` ? N extends keyof T ? T[N] : number extends keyof T ? T[number] : never : never;
+/**
+ * What a path may do, for one use of it: go below a list or a whole value,
+ * as a rule or a request may, and end at a struct, as the fields of a rule
+ * may. See {@link FieldPath}, {@link FieldSelector} and {@link FieldName},
+ * which list the short paths with the same rules.
+ */
+interface PathRules {
+  readonly arrays: boolean;
+  readonly parents: boolean;
+}
+/** The rules of a path that a condition reads. */
+interface ReadRules {
+  readonly arrays: false;
+  readonly parents: false;
+}
+/** The rules of the field of a request. */
+interface SelectRules {
+  readonly arrays: true;
+  readonly parents: false;
+}
+/** The rules of a field of a rule, which may name a struct. */
+interface NameRules {
+  readonly arrays: true;
+  readonly parents: true;
+}
+/** The objects below a field with the values `V`: see `PathsOf`. */
+type ObjectsBelow<V, Arrays extends boolean> = Arrays extends true ? Exclude<V, Leaf | Whole | Function | ReadonlyArray<unknown>> : [Extract<V, Whole | Function | ReadonlyArray<unknown>>] extends [never] ? Exclude<V, Leaf> : never;
+/** Tests if `Name` names a field of every object of `O`, as `keyof` does. */
+type HasPart<O, Name extends string> = Name extends keyof O ? true : Name extends `${infer N extends number}` ? N extends keyof O ? true : number extends keyof O ? true : false : false;
+/**
+ * The objects below the part `Name` of the objects `O`, for a path that goes
+ * on, or `never` when it can not go on.
+ */
+type PathStep<O, Name extends string, R extends PathRules> = HasPart<O, Name> extends true ? ObjectsBelow<NonNullable<ChildOf<O, Name>>, R["arrays"]> : never;
+/** Tests if a path may end at a field with the values `V`: see `PathsOf`. */
+type EndsAt<V, R extends PathRules, Last extends boolean> = [V] extends [never] ? true : {} extends V ? true : [Extract<V, Leaf | Whole>] extends [never] ? R["arrays"] extends true ? [Extract<V, ReadonlyArray<unknown>>] extends [never] ? EndsAtObjects<ObjectsBelow<V, true>, R, Last> : true : false : true;
+/**
+ * Tests if a path may end at a field that holds the objects `O`: a field of a
+ * rule may name a struct, and a request may name a record, or a struct at
+ * the last part that a path may have.
+ */
+type EndsAtObjects<O, R extends PathRules, Last extends boolean> = [O] extends [never] ? false : R["parents"] extends true ? true : string extends keyof O ? true : number extends keyof O ? true : Last;
+/** The paths one part below `Done`, as the names that may come next. */
+type NextNames<O, Done extends string> = `${Done}${keyof O & (string | number)}`;
+/**
+ * Walks a path two parts at a time, from the objects `O`. It gives `true`
+ * for a path that the rules `R` take, or the names that may come next after
+ * the last good part. `Count` counts the parts before `F`, so the walk knows
+ * the last part that a path may have: part 1000, the default of
+ * `Limits.fieldPathParts`.
+ */
+type PathWalk<O, F extends string, Done extends string, R extends PathRules, Count extends ReadonlyArray<0>> = F extends `${infer A}.${infer B}.${infer Rest}` ? PathStep<O, A, R> extends (infer O1) ? [O1] extends [never] ? NextNames<O, Done> : PathStep<O1, B, R> extends (infer O2) ? [O2] extends [never] ? NextNames<O1, `${Done}${A}.`> : PathWalk<O2, Rest, `${Done}${A}.${B}.`, R, [...Count, 0, 0]> : never : never : F extends `${infer A}.${infer B}` ? PathStep<O, A, R> extends (infer O1) ? [O1] extends [never] ? NextNames<O, Done> : PathEnd<O1, B, `${Done}${A}.`, R, [...Count, 0]> : never : PathEnd<O, F, Done, R, Count>;
+type PathEnd<O, Name extends string, Done extends string, R extends PathRules, Count extends ReadonlyArray<0>> = HasPart<O, Name> extends true ? EndsAt<NonNullable<ChildOf<O, Name>>, R, Count["length"] extends 999 ? true : false> extends true ? true : NextNames<ObjectsBelow<NonNullable<ChildOf<O, Name>>, R["arrays"]>, `${Done}${Name}.`> : NextNames<O, Done>;
+/**
+ * Checks one field path `F` of `T`, of any length up to about 1000 parts.
+ * It gives `F` for a path that the rules `R` take. For another path, it gives
+ * the paths that may come next after its last good part, so a type error
+ * names them. For a union of types, a part must be in each of them.
+ */
+type PathCheck<T, F extends string, R extends PathRules> = [T] extends [object] ? PathWalk<T, F, "", R, []> extends true ? F : NoInfer<PathWalk<T, F, "", R, []>> : never;
+/**
+ * A path of `T` that a condition may read, as one of {@link FieldPath}, of
+ * any length up to about 1000 parts. It is `F` when `F` is such a path, and
+ * the names that may come next when it is not.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 2.1.0
+ */
+export type ReadPath<T, F extends string> = PathCheck<T, F, ReadRules>;
+/**
+ * A path of `T` that a request may name, as one of {@link FieldSelector}, of
+ * any length up to about 1000 parts. See {@link ReadPath}.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 2.1.0
+ */
+export type SelectPath<T, F extends string> = PathCheck<T, F, SelectRules>;
+/**
+ * A path of `T` that a field of a rule may name, as one of
+ * {@link FieldName}, of any length up to about 1000 parts. See
+ * {@link ReadPath}.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 2.1.0
+ */
+export type NamePath<T, F extends string> = PathCheck<T, F, NameRules>;
+/** A path that a condition may read, with an ordered value. */
+type OrderedReadPath<T, F extends string> = ReadPath<T, F> extends F ? Exclude<PathValue<T, F>, null> extends number | string ? F : never : ReadPath<T, F>;
+/** A path that a condition may read, with a scalar value. */
+type ScalarReadPath<T, F extends string> = ReadPath<T, F> extends F ? PathValue<T, F> extends Scalar ? F : never : ReadPath<T, F>;
 /**
  * A value for a field of type `A`: a fixed value, or a field of the principal
  * with the same type.
@@ -351,8 +453,6 @@ type ChildOf<T, Name extends string> = Name extends keyof T ? T[Name] : Name ext
  * @since 0.3.0
  */
 export type OperandOf<A, P = never> = Extract<A, Scalar> | Ref<A, P>;
-type ScalarPath<T> = { [F in FieldPath<T>]: PathValue<T, F> extends Scalar ? F : never; }[FieldPath<T>];
-type OrderedPath<T> = { [F in FieldPath<T>]: Exclude<PathValue<T, F>, null> extends number | string ? F : never; }[FieldPath<T>];
 /**
  * A test made by a {@link Builder}. It runs no code, but it keeps the value
  * type of its resource, so a test on the fields of one resource can not go
@@ -382,24 +482,24 @@ type PrincipalOf<V, _P> = [Extract<V, PrincipalRef>] extends [never] ? unknown :
  */
 export interface Builder<Data, Value, P> {
   /** The field is equal to the value. */
-  readonly eq: <const F extends FieldPath<Data>, const V extends OperandOf<FieldValue<Data, F>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
+  readonly eq: <const F extends string, const V extends OperandOf<FieldValue<Data, F>, any>>(field: ReadPath<Data, F>, value: V) => Test<Value, PrincipalOf<V, P>>;
   /** The field is not equal to the value. */
-  readonly ne: <const F extends FieldPath<Data>, const V extends OperandOf<FieldValue<Data, F>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
-  readonly lt: <const F extends OrderedPath<Data>, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
-  readonly lte: <const F extends OrderedPath<Data>, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
-  readonly gt: <const F extends OrderedPath<Data>, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
-  readonly gte: <const F extends OrderedPath<Data>, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
+  readonly ne: <const F extends string, const V extends OperandOf<FieldValue<Data, F>, any>>(field: ReadPath<Data, F>, value: V) => Test<Value, PrincipalOf<V, P>>;
+  readonly lt: <const F extends string, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: OrderedReadPath<Data, F>, value: V) => Test<Value, PrincipalOf<V, P>>;
+  readonly lte: <const F extends string, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: OrderedReadPath<Data, F>, value: V) => Test<Value, PrincipalOf<V, P>>;
+  readonly gt: <const F extends string, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: OrderedReadPath<Data, F>, value: V) => Test<Value, PrincipalOf<V, P>>;
+  readonly gte: <const F extends string, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: OrderedReadPath<Data, F>, value: V) => Test<Value, PrincipalOf<V, P>>;
   /** The field is equal to one of the values. */
-  readonly in: <const F extends FieldPath<Data>, const Vs extends ReadonlyArray<OperandOf<FieldValue<Data, F>, any>>>(field: F, values: Vs) => Test<Value, PrincipalOf<Vs[number], P>>;
+  readonly in: <const F extends string, const Vs extends ReadonlyArray<OperandOf<FieldValue<Data, F>, any>>>(field: ReadPath<Data, F>, values: Vs) => Test<Value, PrincipalOf<Vs[number], P>>;
   /** The field has a value that is not `null`. */
-  readonly exists: <const F extends FieldPath<Data>>(field: F) => Test<Value>;
+  readonly exists: <const F extends string>(field: ReadPath<Data, F>) => Test<Value>;
   /** The path of the resource starts with these parts. */
   readonly under: <const Ps extends ReadonlyArray<string | null | Ref<string | null, any>>>(...prefix: Ps) => Test<Value, PrincipalOf<Ps[number], P>>;
   /**
    * A field of the principal, to use as a value. The field must have a
    * {@link Scalar} type.
    */
-  readonly principal: <const F extends ScalarPath<P>>(field: F) => Ref<PathValue<P, F>, P>;
+  readonly principal: <const F extends string>(field: ScalarReadPath<P, F>) => Ref<PathValue<P, F>, P>;
   readonly and: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>>;
   readonly or: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>>;
   readonly not: <C extends Any>(condition: C) => Condition<ReadsOf<C>, OpaqueOf<C>>;

package/dist/Condition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Condition.d.ts","names":["Nodes.Scalar","Nodes.Literal","Nodes.PrincipalRef","Nodes.CompareOperator","Nodes.True","Nodes.False","Nodes.Compare","Nodes.In","Nodes.Exists","Nodes.Under","Nodes.And","Nodes.Or","Nodes.Not","Nodes.Predicate","Nodes.Node","Resource.PathSegment","Search.Example","Search.Satisfiability"],"sources":["../src/Condition.ts"],"mappings":"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"}
+{"version":3,"file":"Condition.d.ts","names":["Nodes.Scalar","Nodes.Literal","Nodes.PrincipalRef","Nodes.CompareOperator","Nodes.True","Nodes.False","Nodes.Compare","Nodes.In","Nodes.Exists","Nodes.Under","Nodes.And","Nodes.Or","Nodes.Not","Nodes.Predicate","Nodes.Node","Resource.PathSegment","Search.Example","Search.Satisfiability"],"sources":["../src/Condition.ts"],"mappings":"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"}

package/dist/Condition.js

@@ -1,13 +1,14 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { run } from "./internal/trampoline.js";
 import { And, Compare, Exists, In, Not, Or, Predicate, Under, always as always$1, isNode, literal, never as never$1, principalRef, toNode } from "./internal/nodes.js";
 import { evaluate as evaluate$1, evaluateSync as evaluateSync$1, fields as fields$1, partial as partial$1, provide, simplify as simplify$1 } from "./internal/algebra.js";
 import { catalogOf } from "./internal/catalog.js";
 import { decode, toJson } from "./internal/json.js";
 import { kindsIn, satisfiable as satisfiable$1 } from "./internal/search.js";
+import * as Arr from "effect/Array";
 import * as Effect from "effect/Effect";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import * as Arr from "effect/Array";
 import { dual } from "effect/Function";
 import { hasProperty } from "effect/Predicate";
 import * as SchemaIssue from "effect/SchemaIssue";
@@ -219,23 +220,31 @@ const literalValue = (operand, field) => {
 	if (operand._tag !== "Literal") throw Untranslatable.make({ reason: `The field "${field}" uses a principal field. Call Condition.partial first.` });
 	return operand.value;
 };
-/** Folds a condition. A shared child is folded again for each place. */
-const foldNode = (node, interpreter) => {
-	switch (node._tag) {
-		case "True": return interpreter.true();
-		case "False": return interpreter.false();
-		case "Compare": return interpreter.compare(node.op, node.field, literalValue(node.value, node.field));
-		case "In": return interpreter.in(node.field, Arr.map(node.values, (operand) => literalValue(operand, node.field)));
-		case "Exists": return interpreter.exists(node.field);
-		case "Under": throw Untranslatable.make({ reason: "An Under node needs the resource path. Call Condition.partial first." });
-		case "And": return interpreter.and(Arr.map(node.conditions, (child) => foldNode(child, interpreter)));
-		case "Or": return interpreter.or(Arr.map(node.conditions, (child) => foldNode(child, interpreter)));
-		case "Not": return interpreter.not(foldNode(node.condition, interpreter));
-		case "Predicate":
-			if (interpreter.predicate === void 0) throw Untranslatable.make({ reason: `The predicate "${node.name}" can not become a query` });
-			return interpreter.predicate(node.name);
-	}
-};
+/**
+* Folds a condition. A shared child is folded again for each place. The walk
+* takes the steps of a trampoline, so a deep condition does not fill the
+* stack.
+*/
+const foldNode = (root, interpreter) => run(root.depth, (R) => {
+	const go = (node) => {
+		const children = (nodes) => R.forEach(nodes, (child) => R.suspend(() => go(child)));
+		switch (node._tag) {
+			case "True": return R.succeed(interpreter.true());
+			case "False": return R.succeed(interpreter.false());
+			case "Compare": return R.succeed(interpreter.compare(node.op, node.field, literalValue(node.value, node.field)));
+			case "In": return R.succeed(interpreter.in(node.field, Arr.map(node.values, (operand) => literalValue(operand, node.field))));
+			case "Exists": return R.succeed(interpreter.exists(node.field));
+			case "Under": throw Untranslatable.make({ reason: "An Under node needs the resource path. Call Condition.partial first." });
+			case "And": return R.map(children(node.conditions), interpreter.and);
+			case "Or": return R.map(children(node.conditions), interpreter.or);
+			case "Not": return R.map(R.suspend(() => go(node.condition)), interpreter.not);
+			case "Predicate":
+				if (interpreter.predicate === void 0) throw Untranslatable.make({ reason: `The predicate "${node.name}" can not become a query` });
+				return R.succeed(interpreter.predicate(node.name));
+		}
+	};
+	return go(root);
+});
 /**
 * Changes a condition into another form with an interpreter. Call
 * {@link partial} first: `fold` fails on principal fields and on `Under`