@nmnmcc/ability 2.0.7 → 2.1.2

package/src/internal/policy.ts

@@ -15,10 +15,12 @@ import * as Condition from "../Condition.ts"
 import type * as Domain from "../Domain.ts"
 import type * as Policy from "../Policy.ts"
 import * as Bind from "./bind.ts"
+import * as Limits from "./limits.ts"
 import * as Nodes from "./nodes.ts"
 import * as PolicyJson from "./policy-json.ts"
 import * as PolicyNodes from "./policy-nodes.ts"
 import * as RuleData from "./rule.ts"
+import * as Trampoline from "./trampoline.ts"
 
 type Any = Policy.Any
 type Node = Policy.Node
@@ -60,8 +62,24 @@ export class PolicyData<
 /** The node of a policy, with no types, for the code below. */
 export const nodeOf = (policy: Any): PolicyNodes.Node => policy.node as never
 
-export const fromNode = (domain: Domain.Any, node: PolicyNodes.Node): any =>
-	new PolicyData({ domain, node })
+/**
+ * Makes a policy of a domain from its tree. The constructors of the nodes
+ * check the ceiling of `policyNodes`, since a node does not know its domain,
+ * so this checks the limit of the domain.
+ */
+export const fromNode = (domain: Domain.Any, node: PolicyNodes.Node): any => {
+	const most = domain.limits.policyNodes
+	if (node.size > most) {
+		throw Limits.exceeded(
+			"A policy tree",
+			"policyNodes",
+			"nodes",
+			node.size,
+			most,
+		)
+	}
+	return new PolicyData({ domain, node })
+}
 
 /**
  * The error when a rule does not fit its domain. It has one issue for each
@@ -191,28 +209,50 @@ const provideNode = (
 					}),
 		]),
 	)
-	const provide = (node: PolicyNodes.Node): PolicyNodes.Node => {
-		if (!node.opaque) {
-			return node
-		}
-		switch (node._tag) {
-			case "Rules":
-				return new PolicyNodes.Rules({
-					algorithm: node.algorithm,
-					rules: Arr.map(node.rules, (value) => provided.get(value) ?? value),
-				})
-			case "All":
-			case "Any":
-			case "FirstOf":
-				return new PolicyNodes[node._tag](Arr.map(node.policies, provide))
-			case "Ceiling":
-				return new PolicyNodes.Ceiling({
-					cap: provide(node.cap),
-					policy: provide(node.policy),
-				})
+	// The walk of the tree takes the steps of a trampoline, so a deep tree
+	// does not fill the stack.
+	return Trampoline.run(root.depth, (R) => {
+		const provide = (
+			node: PolicyNodes.Node,
+		): Trampoline.Step<PolicyNodes.Node> => {
+			if (!node.opaque) {
+				return R.succeed(node)
+			}
+			switch (node._tag) {
+				case "Rules":
+					return R.succeed(
+						new PolicyNodes.Rules({
+							algorithm: node.algorithm,
+							rules: Arr.map(
+								node.rules,
+								(value) => provided.get(value) ?? value,
+							),
+						}),
+					)
+				case "All":
+				case "Any":
+				case "FirstOf": {
+					const tag = node._tag
+					return R.map(
+						R.forEach(node.policies, (child) =>
+							R.suspend(() => provide(child)),
+						),
+						(policies) => new PolicyNodes[tag](policies),
+					)
+				}
+				case "Ceiling":
+					return R.flatMap(
+						R.suspend(() => provide(node.cap)),
+						(cap) =>
+							R.map(
+								R.suspend(() => provide(node.policy)),
+								(policy) => new PolicyNodes.Ceiling({ cap, policy }),
+							),
+					)
+			}
 		}
-	}
-	return provide(root)
+		return provide(root)
+	})
 }
 
 /** Gives the services in `context` to every predicate of a policy. */

package/src/internal/rule.ts

@@ -12,6 +12,7 @@ import type * as Domain from "../Domain.ts"
 import type * as Policy from "../Policy.ts"
 import type * as Resource from "../Resource.ts"
 import * as Catalog from "./catalog.ts"
+import * as Limits from "./limits.ts"
 import * as Nodes from "./nodes.ts"
 import * as ResourceData from "./resource.ts"
 import * as Patterns from "./patterns.ts"
@@ -167,6 +168,7 @@ export const matchesInside = (pattern: string, field: string): boolean =>
  */
 export const fitsOf = (
 	catalog: Catalog.Catalog,
+	parts: number,
 ): ((pattern: string) => boolean) => {
 	// A native `Map`: the hash of a string in Effect has no random seed, and a
 	// policy could hold very many patterns with one hash. The engine hashes a
@@ -177,7 +179,11 @@ export const fitsOf = (
 		if (known !== undefined) {
 			return known
 		}
-		const found = Patterns.fitsCatalog(Patterns.parseBound(pattern), catalog)
+		const found = Patterns.fitsCatalog(
+			Patterns.parseBound(pattern),
+			catalog,
+			parts,
+		)
 		memo.set(pattern, found)
 		return found
 	}
@@ -205,6 +211,8 @@ export const matchesTarget = (
 		readonly descriptor?: Resource.Descriptor | undefined
 		/** The test of {@link fitsOf} for the catalog of the descriptor. */
 		readonly fits?: ((pattern: string) => boolean) | undefined
+		/** The most parts of a field path in the domain. */
+		readonly parts?: number | undefined
 	},
 ): boolean => {
 	if (!rule.actions.includes("*") && !rule.actions.includes(target.action)) {
@@ -226,7 +234,11 @@ export const matchesTarget = (
 		return (
 			rule._tag === "Allow" &&
 			(descriptor === undefined ||
-				Arr.some(rule.fields, target.fits ?? fitsOf(descriptor.catalog)))
+				Arr.some(
+					rule.fields,
+					target.fits ??
+						fitsOf(descriptor.catalog, target.parts ?? Limits.fieldPathParts),
+				))
 		)
 	}
 	const field = target.field
@@ -236,7 +248,8 @@ export const matchesTarget = (
 	const open =
 		rule._tag === "Deny" &&
 		target.descriptor !== undefined &&
-		(Catalog.lookup(target.descriptor.catalog, field)?.open ?? false)
+		(Catalog.lookup(target.descriptor.catalog, field, target.parts)?.open ??
+			false)
 	return rule.fields.some(
 		(pattern) =>
 			matchesField(pattern, field) || (open && matchesInside(pattern, field)),

package/src/internal/search.ts

@@ -17,6 +17,7 @@ import * as Algebra from "./algebra.ts"
 import * as Catalog from "./catalog.ts"
 import * as Limits from "./limits.ts"
 import * as Nodes from "./nodes.ts"
+import * as Trampoline from "./trampoline.ts"
 
 type Node = Nodes.Node
 
@@ -279,51 +280,65 @@ const testFixed = (
 }
 
 /** Puts one value into a field, and into the fields below it. */
-const fix = (
-	node: Node,
-	field: string,
-	value: unknown,
-	search: Search,
-): Node => {
-	const fixChild = (child: Node) => fix(child, field, value, search)
-	switch (node._tag) {
-		case "Compare":
-		case "In":
-		case "Exists": {
-			const known = fixedValue(node.field, field, value)
-			return known === free
-				? node
-				: testFixed(node, known, search)
-					? Nodes.always
-					: Nodes.never
+const fix = (root: Node, field: string, value: unknown, search: Search): Node =>
+	// The walks of a condition take the steps of a trampoline, so a deep
+	// condition does not fill the stack.
+	Trampoline.run(root.depth, (R) => {
+		const go = (node: Node): Trampoline.Step<Node> => {
+			const children = (nodes: ReadonlyArray<Node>) =>
+				R.forEach(nodes, (child) => R.suspend(() => go(child)))
+			switch (node._tag) {
+				case "Compare":
+				case "In":
+				case "Exists": {
+					const known = fixedValue(node.field, field, value)
+					return R.succeed(
+						known === free
+							? node
+							: testFixed(node, known, search)
+								? Nodes.always
+								: Nodes.never,
+					)
+				}
+				case "And":
+					return R.map(children(node.conditions), Algebra.and)
+				case "Or":
+					return R.map(children(node.conditions), Algebra.or)
+				case "Not":
+					return R.map(
+						R.suspend(() => go(node.condition)),
+						Algebra.not,
+					)
+				default:
+					return R.succeed(node)
+			}
 		}
-		case "And":
-			return Algebra.and(Arr.map(node.conditions, fixChild))
-		case "Or":
-			return Algebra.or(Arr.map(node.conditions, fixChild))
-		case "Not":
-			return node.condition.pipe(fixChild, Algebra.not)
-		default:
-			return node
-	}
-}
+		return go(root)
+	})
 
 /** The fields of the tests of a condition, once for each test. */
-const testedFields = (node: Node): ReadonlyArray<string> => {
-	switch (node._tag) {
-		case "Compare":
-		case "In":
-		case "Exists":
-			return [node.field]
-		case "And":
-		case "Or":
-			return Arr.flatMap(node.conditions, testedFields)
-		case "Not":
-			return testedFields(node.condition)
-		default:
-			return []
-	}
-}
+const testedFields = (root: Node): ReadonlyArray<string> =>
+	Trampoline.run(root.depth, (R) => {
+		const go = (node: Node): Trampoline.Step<ReadonlyArray<string>> => {
+			switch (node._tag) {
+				case "Compare":
+				case "In":
+				case "Exists":
+					return R.succeed([node.field])
+				case "And":
+				case "Or":
+					return R.map(
+						R.forEach(node.conditions, (child) => R.suspend(() => go(child))),
+						Arr.flatten,
+					)
+				case "Not":
+					return R.suspend(() => go(node.condition))
+				default:
+					return R.succeed([])
+			}
+		}
+		return go(root)
+	})
 
 /**
  * Picks the next field to split on. A field comes before the fields below it,
@@ -353,59 +368,66 @@ const nextField = (node: Node): string => {
  * one field at a time, and tries one value from each cell of the field. Each
  * step reads the whole condition, so the budget counts its size.
  */
-const searchNode = (
-	node: Node,
-	search: Search,
-	state: SearchState,
-	assignment: ReadonlyArray<readonly [string, unknown]>,
-): Found => {
-	if (node._tag === "True") {
-		return { assignment: Option.some(assignment), state }
-	}
-	if (node._tag === "False") {
-		return { assignment: Option.none(), state }
-	}
-	// The key reads at most a small part of the node: a node with very many
-	// nodes, or with very many values in its `In` tests, is its own key. A
-	// step reads the nodes but not the values, which `membersOf` keeps, so the
-	// budget counts the size.
-	const key = Algebra.keyOf(node)
-	if (search.failed.has(key)) {
-		return { assignment: Option.none(), state }
-	}
-	if (state.steps + node.size > search.budget) {
-		throw new OutOfBudget()
-	}
-	const field = nextField(node)
-	// The cells are tried in order, until one gives values. A fold over the
-	// cells does no work after a found answer, and it does not grow the stack
-	// with the number of cells.
-	const result = Arr.reduce(
-		search.cells(field),
-		{
-			assignment: Option.none(),
-			state: { ...state, steps: state.steps + node.size },
-		} as Found,
-		(before, cell): Found => {
-			if (Option.isSome(before.assignment)) {
-				return before
-			}
-			const steps = before.state.steps + node.size
-			if (steps > search.budget) {
-				throw new OutOfBudget()
-			}
-			return searchNode(
-				fix(node, field, cell, search),
-				search,
-				{ ...before.state, steps },
-				[...assignment, [field, cell]],
-			)
-		},
-	)
-	if (Option.isNone(result.assignment)) {
-		search.failed.add(key)
+const searchNode = (search: Search) => (R: Trampoline.Runner) => {
+	const go = (
+		node: Node,
+		state: SearchState,
+		assignment: ReadonlyArray<readonly [string, unknown]>,
+	): Trampoline.Step<Found> => {
+		if (node._tag === "True") {
+			return R.succeed({ assignment: Option.some(assignment), state })
+		}
+		if (node._tag === "False") {
+			return R.succeed({ assignment: Option.none(), state })
+		}
+		// The key reads at most a small part of the node: a node with very
+		// many nodes, or with very many values in its `In` tests, is its own
+		// key. A step reads the nodes but not the values, which `membersOf`
+		// keeps, so the budget counts the size.
+		const key = Algebra.keyOf(node)
+		if (search.failed.has(key)) {
+			return R.succeed({ assignment: Option.none(), state })
+		}
+		if (state.steps + node.size > search.budget) {
+			throw new OutOfBudget()
+		}
+		const field = nextField(node)
+		// The cells are tried in order, until one gives values. A fold over
+		// the cells does no work after a found answer, and it does not grow
+		// the stack with the number of cells. Each call for the next field
+		// is a step of the runner, so very many fields do not fill the stack.
+		return R.map(
+			R.reduce(
+				search.cells(field),
+				{
+					assignment: Option.none(),
+					state: { ...state, steps: state.steps + node.size },
+				} as Found,
+				(before, cell): Trampoline.Step<Found> => {
+					if (Option.isSome(before.assignment)) {
+						return R.succeed(before)
+					}
+					const steps = before.state.steps + node.size
+					if (steps > search.budget) {
+						throw new OutOfBudget()
+					}
+					return R.suspend(() =>
+						go(fix(node, field, cell, search), { ...before.state, steps }, [
+							...assignment,
+							[field, cell],
+						]),
+					)
+				},
+			),
+			(result) => {
+				if (Option.isNone(result.assignment)) {
+					search.failed.add(key)
+				}
+				return result
+			},
+		)
 	}
-	return result
+	return go
 }
 
 /**
@@ -413,28 +435,40 @@ const searchNode = (
  * parts (`opaque`) becomes an empty object, and it keeps an object that is
  * there.
  */
+type Fields = Readonly<Record<string, unknown>>
+
 const setPath = (
-	root: Readonly<Record<string, unknown>>,
+	root: Fields,
 	names: ReadonlyArray<string>,
 	value: unknown,
-): Readonly<Record<string, unknown>> => {
-	const [name, ...rest] = names
-	if (name === undefined) {
+): Fields => {
+	const last = names[names.length - 1]
+	if (last === undefined) {
 		return root
 	}
 	// Only an own field counts, as a condition reads it. An inherited one,
 	// such as `__proto__`, is not a field of the example.
-	const inner = Object.hasOwn(root, name) ? root[name] : undefined
-	if (rest.length === 0) {
-		return value === opaque && isObject(inner)
-			? root
-			: { ...root, [name]: value === opaque ? {} : value }
-	}
-	const base =
-		isObject(inner) && inner !== opaque
-			? (inner as Readonly<Record<string, unknown>>)
-			: {}
-	return { ...root, [name]: setPath(base, rest, value) }
+	const own = (base: Fields, name: string): unknown =>
+		Object.hasOwn(base, name) ? base[name] : undefined
+	// The object at each part of the path, from the root down to the object
+	// that gets the value. A part that is not an object becomes empty. The
+	// path is walked in a loop, so a long path does not fill the stack.
+	const bases = Arr.scan(names.slice(0, -1), root, (base, name): Fields => {
+		const inner = own(base, name)
+		return isObject(inner) && inner !== opaque ? (inner as Fields) : {}
+	})
+	const target = bases[bases.length - 1]!
+	const inner = own(target, last)
+	const placed: Fields =
+		value === opaque && isObject(inner)
+			? target
+			: { ...target, [last]: value === opaque ? {} : value }
+	// Each object above gets the new object below it, from the bottom up.
+	return Arr.reduceRight(
+		names.slice(0, -1),
+		placed,
+		(below, name, index): Fields => ({ ...bases[index]!, [name]: below }),
+	)
 }
 
 const exampleOf = (
@@ -452,31 +486,42 @@ const exampleOf = (
  * belongs to one search.
  */
 const constantsOf = (node: Node): Map<string, Set<Nodes.Scalar>> => {
-	const pairs = (
-		current: Node,
-	): ReadonlyArray<readonly [string, ReadonlyArray<Nodes.Scalar>]> => {
-		switch (current._tag) {
-			case "Compare":
-				return [[current.field, [literalOf(current.value)]]]
-			case "In":
-				return [[current.field, Arr.map(current.values, literalOf)]]
-			case "Exists":
-				return [[current.field, []]]
-			case "Under":
-				throw new Error(
-					"Condition.satisfiable needs a condition with no Under nodes. Call Condition.partial first.",
-				)
-			case "And":
-			case "Or":
-				return Arr.flatMap(current.conditions, pairs)
-			case "Not":
-				return pairs(current.condition)
-			default:
-				return []
+	type Pair = readonly [string, ReadonlyArray<Nodes.Scalar>]
+	// The walk takes the steps of a trampoline, so a deep condition does not
+	// fill the stack.
+	const pairs = Trampoline.run(node.depth, (R) => {
+		const go = (current: Node): Trampoline.Step<ReadonlyArray<Pair>> => {
+			switch (current._tag) {
+				case "Compare":
+					return R.succeed([[current.field, [literalOf(current.value)]]])
+				case "In":
+					return R.succeed([
+						[current.field, Arr.map(current.values, literalOf)],
+					])
+				case "Exists":
+					return R.succeed([[current.field, []]])
+				case "Under":
+					throw new Error(
+						"Condition.satisfiable needs a condition with no Under nodes. Call Condition.partial first.",
+					)
+				case "And":
+				case "Or":
+					return R.map(
+						R.forEach(current.conditions, (child) =>
+							R.suspend(() => go(child)),
+						),
+						Arr.flatten,
+					)
+				case "Not":
+					return R.suspend(() => go(current.condition))
+				default:
+					return R.succeed([])
+			}
 		}
-	}
+		return go(node)
+	})
 	const all = new Map<string, Set<Nodes.Scalar>>()
-	Arr.forEach(pairs(node), ([field, values]) => {
+	Arr.forEach(pairs, ([field, values]) => {
 		const known = all.get(field) ?? new Set<Nodes.Scalar>()
 		Arr.forEach(values, (value) => known.add(value))
 		all.set(field, known)
@@ -486,9 +531,9 @@ const constantsOf = (node: Node): Map<string, Set<Nodes.Scalar>> => {
 
 /** Gives the kinds of each field of a catalog. A field that it does not have may hold any value. */
 export const kindsIn =
-	(catalog: Catalog.Catalog | undefined) =>
+	(catalog: Catalog.Catalog | undefined, parts?: number) =>
 	(field: string): Catalog.Kinds =>
-		(catalog === undefined ? undefined : Catalog.lookup(catalog, field))
+		(catalog === undefined ? undefined : Catalog.lookup(catalog, field, parts))
 			?.kinds ?? Catalog.anyKinds
 
 /**
@@ -500,13 +545,14 @@ export const satisfiable = (
 	node: Node,
 	kindsOf: (field: string) => Catalog.Kinds,
 	budget: number = Limits.searchSteps,
+	fields: number = Limits.searchFields,
 ): Satisfiability => {
 	if (node.opaque) {
 		return satisfiability.Unknown({ reason: "predicate" })
 	}
 	const constants = constantsOf(node)
 	// The search calls itself one time for each field that it fixes.
-	if (constants.size > Limits.searchFields) {
+	if (constants.size > fields) {
 		return satisfiability.Unknown({ reason: "budget" })
 	}
 	// The cells of each field, in a native `Map` as the constants are.
@@ -532,7 +578,11 @@ export const satisfiable = (
 		budget,
 	}
 	try {
-		const found = searchNode(Algebra.simplify(node), search, { steps: 0 }, [])
+		// The search goes one call deeper for each field, so the runner is the
+		// one for that many levels.
+		const found = Trampoline.run(constants.size, (R) =>
+			searchNode(search)(R)(Algebra.simplify(node), { steps: 0 }, []),
+		)
 		return Option.match(found.assignment, {
 			onNone: () => satisfiability.Unsatisfiable(),
 			onSome: (assignment) =>

package/src/internal/trampoline.ts

@@ -41,6 +41,15 @@ export interface Runner {
 		items: ReadonlyArray<A>,
 		f: (item: A, index: number) => Step<B>,
 	) => Step<ReadonlyArray<B>>
+	/**
+	 * Runs a step for each item, in order, with the value of the step before.
+	 * It does not grow the stack with the number of items.
+	 */
+	readonly reduce: <A, B>(
+		items: ReadonlyArray<A>,
+		initial: B,
+		f: (before: B, item: A) => Step<B>,
+	) => Step<B>
 	/** Runs a step for each item, in order, up to the first `true`. */
 	readonly some: <A>(
 		items: ReadonlyArray<A>,
@@ -58,15 +67,18 @@ const value = <A>(step: Step<A>): A => step as unknown as A
 const step = <A>(value: A): Step<A> => value as unknown as Step<A>
 
 /** Runs each step at once, on the stack. */
+// A step of `direct` is its value, so a function that gives a step gives a
+// value too. The runner passes such a function on with no wrap: a wrap for
+// each item would be a call more for each node of a walk.
 export const direct: Runner = {
 	succeed: step,
 	suspend: (make) => make(),
 	map: (from, f) => step(f(value(from))),
 	flatMap: (from, f) => f(value(from)),
-	forEach: (items, f) =>
-		step(Arr.map(items, (item, index) => value(f(item, index)))),
-	some: (items, f) => step(Arr.some(items, (item) => value(f(item)))),
-	every: (items, f) => step(Arr.every(items, (item) => value(f(item)))),
+	forEach: (items, f) => step(Arr.map(items, f as never)),
+	reduce: (items, initial, f) => step(Arr.reduce(items, initial, f as never)),
+	some: (items, f) => step(Arr.some(items, f as never)),
+	every: (items, f) => step(Arr.every(items, f as never)),
 }
 
 // A step of `loop` is an Effect with no error and no services. A failure of a
@@ -84,6 +96,14 @@ export const loop: Runner = {
 		fromEffect(Effect.flatMap(effect(from), (value) => effect(f(value)))),
 	forEach: (items, f) =>
 		fromEffect(Effect.forEach(items, (item, index) => effect(f(item, index)))),
+	reduce: (items, initial, f) =>
+		fromEffect(
+			Effect.reduce(
+				items,
+				() => initial,
+				(before, item) => effect(f(before, item)),
+			),
+		),
 	some: (items, f) =>
 		fromEffect(
 			Effect.map(
@@ -140,6 +160,33 @@ export const runWith = <A>(
 	})
 }
 
+/**
+ * Makes a walk of an input with an unknown depth, as the input of a decoder.
+ * It runs with `direct` while the input is low. A part more than
+ * `directDepth` levels down runs with `loop`, and the walk stays in the loop
+ * below it, so it goes into the loop one time on each path. `walk` gets the
+ * runner, and the call for a child at the next level: `child(item, depth)`.
+ */
+export const adaptive = <I, A>(
+	walk: (
+		R: Runner,
+		child: (item: I, depth: number) => Step<A>,
+	) => (item: I, depth: number) => Step<A>,
+): ((item: I) => A) => {
+	const inLoop: (item: I, depth: number) => Step<A> = walk(
+		loop,
+		(item, depth) => loop.suspend(() => inLoop(item, depth)),
+	)
+	const onStack: (item: I, depth: number) => Step<A> = walk(
+		direct,
+		(item, depth) =>
+			depth > directDepth
+				? step(runWith(loop, () => inLoop(item, depth)))
+				: onStack(item, depth),
+	)
+	return (item) => value(onStack(item, 1))
+}
+
 /**
  * Gives the Effect of a step of `loop`, so a walk can go on in an Effect
  * that runs a predicate.